source: nrEngine/src/Log.cpp @ 1

Revision 1, 5.6 KB checked in by art, 13 years ago (diff)
Line 
1/***************************************************************************
2 *                                                                         *
3 *   (c) Art Tevs, MPI Informatik Saarbruecken                             *
4 *       mailto: <tevs@mpi-sb.mpg.de>                                      *
5 *                                                                         *
6 *   This program is free software; you can redistribute it and/or modify  *
7 *   it under the terms of the GNU General Public License as published by  *
8 *   the Free Software Foundation; either version 2 of the License, or     *
9 *   (at your option) any later version.                                   *
10 *                                                                         *
11 ***************************************************************************/
12
13
14#include "Log.h"
15#include <iostream>
16#include <time.h>
17
18namespace nrEngine{
19
20        //-------------------------------------------------------------------------
21        Log::Log()
22        {
23                _logLevel = LL_NORMAL;
24        }
25       
26        //-------------------------------------------------------------------------
27        Log::~Log()
28        {       
29                log (LOG_ANYTHING, LL_DEBUG, "Logging stopped");
30               
31                // close streams
32                _kernelLog.close();
33                _engineLog.close();
34                _serverLog.close();
35                _clientLog.close();
36                _pluginLog.close();
37                _appLog.close();
38        }
39       
40        //-------------------------------------------------------------------------
41        Result Log::initialize(const ::std::string& logPath){
42               
43                this->logPath = logPath;
44               
45                // open log files
46                _appLog.open((logPath + "/application.log").c_str(),::std::ios::out);// | ios::app);
47                _kernelLog.open((logPath + "/kernel.log").c_str(), ::std::ios::out);// | ios::app);
48                //_clientLog.open((logPath + "/client.log").c_str(), ::std::ios::out);// | ios::app);
49                //_serverLog.open((logPath + "/server.log").c_str(), ::std::ios::out);// | ios::app);
50                _engineLog.open((logPath + "/engine.log").c_str(), ::std::ios::out);// | ios::app);
51                _pluginLog.open((logPath + "/plugin.log").c_str(), ::std::ios::out);// | ios::app);
52                       
53                log (LOG_ANYTHING, LL_DEBUG, "Logging activated");
54                               
55                return OK;
56        }
57       
58        //-------------------------------------------------------------------------
59        void Log::log(LogTarget target, const char* msg, ...)
60        {
61                // check whenver we have already initialised the log engine
62                /*if (logPath.length() == 0){
63                        static bool warned = false;
64                        if (warned == false){
65                                logIt(LOG_CONSOLE, LL_WARNING, "You can not log messages before you initialize the log engine");
66                                warned = true;
67                        }
68                        return;
69                }*/
70                       
71                // get messages
72                va_list args; 
73                va_start(args,msg);
74                char szBuf[2056];
75                memset(szBuf, 0, sizeof(char)*2056);
76                vsprintf(szBuf,msg,args);
77                va_end(args);
78               
79                // log the message
80                logIt(target, LL_NORMAL, szBuf);
81               
82                // echo logging
83                if (_echoMap[target]){
84                        logIt(_echoMap[target], LL_NORMAL, szBuf);
85                }
86
87        }
88       
89        //-------------------------------------------------------------------------
90        void Log::log(LogTarget target, LogLevel level, const char* msg, ...)
91        {
92       
93                // check whenver we have already initialised the log engine
94                /*if (logPath.length() == 0){
95                        static bool warned = false;
96                        if (warned == false){
97                                logIt(LOG_CONSOLE, LL_WARNING, "You can not log messages before you initialize the log engine");
98                                warned = true;
99                        }
100                        return;
101                }*/
102                       
103                // get messages
104                va_list args; 
105                va_start(args,msg);
106                char szBuf[2056];
107                memset(szBuf, 0, sizeof(char)*2056);
108                vsprintf(szBuf,msg,args);
109                va_end(args);
110               
111                // log the message
112                logIt(target, level, szBuf);
113               
114                // echo logging
115                if (_echoMap[target]){
116                        logIt(_echoMap[target], level, szBuf);
117                }
118               
119        }
120
121        //-------------------------------------------------------------------------
122        void Log::logIt(int32 target, LogLevel level, const char *msg){
123
124                // check whenever the coming message is allowed to be logged
125                if (level > _logLevel) return;
126               
127                // get messages
128                const char *szBuf = msg;
129               
130                // Get time & date string
131                time_t _time = time(NULL);
132                tm* time = localtime(&_time);
133               
134                // create the string before the message         
135                char timeDate[255];
136                std::string sLevel = getLevelStr(level);
137                if (time != NULL)
138                        sprintf(timeDate, "%02d:%02d:%02d - %s", time->tm_hour, time->tm_min, time->tm_sec, sLevel.c_str());
139                else
140                        sprintf(timeDate, "%s", sLevel.c_str());
141
142                                               
143                // Check whereever to log
144                if((target & LOG_APP) && _appLog.is_open()){
145                        _appLog << timeDate << ": " << szBuf << "\n";
146                        _appLog.flush();
147                }
148               
149                if((target & LOG_CLIENT) && _clientLog.is_open()){
150                        _clientLog << timeDate << ": " << szBuf << "\n";
151                        _clientLog.flush();
152                }
153               
154                if((target & LOG_SERVER) && _serverLog.is_open()){
155                        _serverLog << timeDate << ": " << szBuf << "\n";
156                        _serverLog.flush();
157                }
158               
159                if((target & LOG_KERNEL) && _kernelLog.is_open()){
160                        _kernelLog << timeDate << ": " << szBuf << "\n";
161                        _kernelLog.flush();
162                }
163               
164                if((target & LOG_ENGINE) && _engineLog.is_open()){
165                        _engineLog << timeDate << ": " << szBuf << "\n";
166                        _engineLog.flush();
167                }
168               
169                if((target & LOG_PLUGIN) && _pluginLog.is_open()){
170                        _pluginLog << timeDate << ": " << szBuf << "\n";
171                        _pluginLog.flush();
172                }
173       
174                if (target & LOG_CONSOLE){
175                        ::std::cout << timeDate << ": " << szBuf << "\n";
176                        ::std::cout.flush();
177                }
178                       
179        }
180
181        //-------------------------------------------------------------------------
182        std::string Log::getLevelStr(LogLevel level)
183        {
184                switch(level){
185                        case LL_FATAL_ERROR: return "FatalError";
186                        case LL_ERROR: return "Error";
187                        case LL_WARNING: return "Warning";
188                        case LL_NORMAL: return "Log";
189                        case LL_DEBUG: return "Debug";
190                        case LL_CHATTY: return "Info";
191                        default: return "";
192                }
193                return "";
194        }
195       
196};// end namespace
197
Note: See TracBrowser for help on using the repository browser.