Logger.java

/*
 *    Copyright (C) 2016  John H. Gaby
 *
 *    This program is free software: you can redistribute it and/or modify
 *    it under the terms of the GNU General Public License as published by
 *    the Free Software Foundation, version 3 of the License.
 *
 *    This program is distributed in the hope that it will be useful,
 *    but WITHOUT ANY WARRANTY; without even the implied warranty of
 *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *    GNU General Public License for more details.
 *
 *    You should have received a copy of the GNU General Public License
 *    along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *    
 *    Contact: robotics@gabysoft.com
 */
 
package robotCore;
 
import java.io.FileNotFoundException;
import java.io.PrintWriter;
import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
 
import org.wpilib.hardware.hal.HALUtil;
 
import robotCore.Network.NetworkReceiver;

 
public class Logger 
{
    private static Object       m_lock = new Object();
    private final static String m_traceName = "trace";
    private final static String m_logDir    = "/home/pi/logs/";
    private static PrintWriter  m_file      = null;
    private static int          m_level     = -999;         // By default, use logging level based on the type
    private static long         m_startTime = HALUtil.getMonotonicMilliseconds();
    private static Network      m_network   = null;
    
    static private PrintWriter createLog(String name)
    {
        DateFormat  dateFormat  = new SimpleDateFormat("MM-dd-HH-mm-ss");
        Date        date        = new Date();
        String      path        = m_logDir + name + dateFormat.format(date) + ".txt";
        PrintWriter file        = null;
        
        try 
        {
            file    = new PrintWriter(path);
        } 
        catch (FileNotFoundException e) 
        {
            e.printStackTrace();
        }   
        
        return(file);
    }
    
    static private class LogType
    {
        private String      m_name          = null;
        private int         m_level         = 0;
        private PrintWriter m_file          = null;
        private boolean     m_logToConsole  = true;
        private boolean     m_logTime       = false;
        
        public LogType(String name)
        {
            m_name  = name;
            
            if (m_name.equals(m_traceName))
            {
                m_logTime   = true;
            }
        }
        
        public void closeLog()
        {
            if (m_file != null);
            {
                m_file.close();
                m_file  = null;
            }
        }
        
        public void createLog(String name, boolean logTime, boolean logToConsole)
        {
            m_logToConsole  = logToConsole;
            m_logTime       = logTime;
            
            if (m_file != null)
            {
                m_file.close();
            }
            
            m_file  = Logger.createLog(name);
        }
        
        public void setLogLevel(int level)
        {
            m_level = level;
        }
    }
    
    static private ArrayList<LogType>   m_types = new ArrayList<LogType>();
    
    static private LogType findType(String tag)
    {
        if (tag == null)
        {
            tag = m_traceName;
        }
        
        for (LogType type : m_types)
        {
            if (type.m_name.equals(tag))
            {
                return(type);
            }
        }
        
        /*
         * Tag not found, add it
         */
        Logger.LogType  newType = new Logger.LogType(tag);
        m_types.add(newType);
        
        return(newType);
    }
    
    static public void log(String tag, int level, String message, boolean noLogToConsole)
    {
        synchronized(m_lock)
        {
            if (level >= m_level)
            {
                LogType type    = findType(tag);
                
                if (level >= type.m_level)
                {
                    PrintWriter file;
                    boolean logTime;
                    
                    if (type.m_file == null)
                    {
                        file    = m_file;
                        logTime = true;         // Always log the time to the master file
                    }
                    else
                    {
                        file    = type.m_file;
                        logTime = type.m_logTime;
                    }
                    
                    if (file != null)
                    {
//                      System.out.println("Log: logTime = " + logTime);
                        if (logTime)
                        {
                            // file.print(getElapsedTime() + ":" + type.m_name + "(" + level + "):");
                            file.print(String.format("%d:%d:%s(%d)", getElapsedTime(), Thread.currentThread().getId(), type.m_name, level));
                        }
                        
                        file.println(message + "\r");
                        file.flush();
                    }
                    
                    if ((file == null) || (type.m_logToConsole && !noLogToConsole))
                    {
                        String log = "" + getElapsedTime() + ":" + type.m_name + "(" + level + "):" + message;
                        System.out.println(log);
                        
                        if (m_network != null)
                        {
//                          String msg = log + "\r\n" + "xxx";
//                          System.out.print("network: " + msg);
                            m_network.sendMessage(log);
                        }
                        
//                      System.out.print(GetElapsedTime() + ":");   // Always log time to console
//                      System.out.println(type.m_name + "(" + level + "):" + message);
                    }
                }
            }
        }
    }
    
    static public void log(String tag, int level, String message)
    {
        log(tag, level, message, false);
    }
    static public void setLogLevel(int level)
    {
        synchronized(m_lock)
        {
            m_level = level;
        }
    }

    static public void setLogLevel(String tag, int level)
    {
        synchronized(m_lock)
        {
            findType(tag).setLogLevel(level);
        }
    }
    
    static public void setLogFile(String name)
    {
        synchronized(m_lock)
        {
            if (m_file != null)
            {
                m_file.close();
            }
            
            m_file  = createLog(name);
        }
    }
    
    static public void setLogFile(String tag, String name)
    {
        setLogFile(tag, name, false, false);
    }
    
    static public void setLogFile(String tag, String name, boolean logTime)
    {
        setLogFile(tag, name, logTime, false);
    }
    
    static public void setLogFile(String tag, String name, boolean logTime, boolean logToConsole)
    {
        synchronized(m_lock)
        {
            findType(tag).createLog(name, logTime, logToConsole);
        }
    }
    
    static public void closeLogFile()
    {
        synchronized(m_lock)
        {
            if (m_file != null)
            {
                m_file.close();
            }
        }
    }

    static public void closeLogFile(String tag)
    {
        synchronized(m_lock)
        {
            findType(tag).closeLog();
        }
    }
    
    static public void closeAllLogFiles()
    {
        closeLogFile();
        
        synchronized(m_lock)
        {
            for (LogType type : m_types)
            {
                type.closeLog();
            }
        }
    }
    
    static public long getElapsedTime()
    {
        synchronized(m_lock)
        {
            return(HALUtil.getMonotonicMilliseconds() - m_startTime);
        }
    }
    
    static public void resetElapsedTime()
    {
        synchronized(m_lock)
        {
            m_startTime = HALUtil.getMonotonicMilliseconds();
        }
    }
    
    static private class Receiver implements NetworkReceiver
    {
        @Override
        public void processData(String command) 
        {
        }
 
        @Override
        public void connected() {
        }
 
        @Override
        public void disconnected() {
        }
    }
    
    static public void startLoggingServer()
    {
        if (m_network == null)
        {
            m_network   = new Network();
            
            m_network.listen(new Receiver(), 5810);
        }
    }
}