/home/fwph/code/wurde/rde/core/Logger.cpp

Go to the documentation of this file.

#include <Logger.H>
#include <WURDEConfiguration.H>

//$Id: Logger.cpp 68 2007-02-01 17:56:57Z fwph $
using namespace WURDE;
using namespace std;

namespace WURDE{
       
       Logger *g_robotLoggerPtr;

       LoggerStream g_logdebug(LOG_DEBUG);
       LoggerStream g_loginfo(LOG_INFO);
       LoggerStream g_lognotice(LOG_NOTICE);
       LoggerStream g_logwarn(LOG_WARNING);
       LoggerStream g_logerror(LOG_ERR);
       LoggerStream g_logfatal(LOG_CRIT);


       Logger::Logger(std::string somename)
              :LoggerTransport("Any"){
              m_logName=somename;
              setGlobalName(somename);
              if(!g_robotLoggerPtr){
                     g_robotLoggerPtr=this;
                     //              m_stream.register_callback(&RobotObjects::theCallback,0);
              }

              //these are just temporary
              m_toFile=false;
              m_toNetwork=false;
              m_toSyslog=false;
              m_toStderr=false;

              m_logLevel=LOG_DEBUG;

              setNetworkLogging(true);
              setStderr(true);
              setSysLogging(true);
              m_init=false;
       };

       Logger::Logger(std::string somename, std::string filename)
              :LoggerTransport("Any"){
              m_logName=somename;
              setGlobalName(somename);
              if(!g_robotLoggerPtr){
                     g_robotLoggerPtr=this;
                     //              m_stream.register_callback(&RobotObjects::theCallback,0);
              }

              //these are just temporary
              m_toFile=false;
              m_toNetwork=false;
              m_toSyslog=false;
              m_toStderr=false;

              // still need to figure out what we're doing here.
              m_outFilename=filename;
              m_init=false;
              setNetworkLogging(true);
              setStderr(true);
              setSysLogging(true);
       }

       void Logger::initLogger(){
              mutex= (pthread_mutex_t)PTHREAD_MUTEX_INITIALIZER;
              m_init=true;
              m_logLevel=g_globalConfiguration.getLogLevel();
       }

       /*
       std::ostream &Logger::flush(){
              cout << " IN flush. " << endl;
              std::ostream & retval=((ostream *)this)->ostream::flush();
              info(this->str());
              ((stringstream *)this)->str(std::string());
              return retval;
       }
       */
       void Logger::log(std::string somestring, int priority){
              if(!m_init){
                     initLogger();
              }

              std::string logstring;
              logstring  =  m_logName + " " + priorityToString(priority) +" " + somestring;           

              if(priority <= m_logLevel){
                     if(m_toSyslog){
                            syslog(priority|LOG_LOCAL0,logstring.c_str());
                     }
                     
                     if(m_toFile){
                            /* endl forces file synchronization */
                            // m_outputFile << ctime(NULL) << " : " << priorityToString(priority) << logstring << endl;
                     }
                     
                     if(m_toNetwork){
                             pthread_mutex_lock(&mutex);
                             data.logFormat="";
                             data.logData.push_back(0);
                             data.logString=somestring.c_str();
                             data.priority=priority;
                             
                             publishData();
                             runUpdate();
                             pthread_mutex_unlock(&mutex);
                     }
              }
       }
       
       
       void Logger::setNetworkLogging(bool value){
              if(value&&!m_toNetwork){
                     data.timestamp.now();
                     data.source=m_globalname;
                     data.logData.push_back(0);
               
                     data.logFormat= " ";
                     data.logString= " ";
              }
              m_toNetwork=false;
              
       }
       
       void Logger::setSysLogging(bool value){
              if(value&&!m_toSyslog){
                     if(m_toStderr){
                            openlog("Robot",LOG_PERROR|LOG_PID,LOG_LOCAL0);
               }else{
                      openlog("Robot",LOG_PID,LOG_LOCAL0);
               }
              }else if(!value&&m_toSyslog){
                     closelog();
              }
              
              m_toSyslog=value;
              
       }
       
       void Logger::setStderr(bool value){
              if(value){
                     if(m_toSyslog&&!m_toStderr){
                            closelog();
                            openlog("Robot",LOG_PERROR|LOG_PID,LOG_LOCAL0);
                     }
              }else{
                     if(m_toSyslog&&m_toStderr){
                            closelog();
                            openlog("Robot",LOG_PID,LOG_LOCAL0);
                     }
              }
              
              m_toStderr=value;
       }
     
       const char * priorityToString( int priority ){
              
              switch(priority){
              case LOG_EMERG:
                     return "[Emergency]";
              case LOG_ALERT:
                     return "[Alert]";
              case LOG_CRIT:
                     return "[Fatal]";
              case LOG_ERR:
                     return "[Error]";
              case LOG_WARNING:
                     return "[Warn]";
              case LOG_NOTICE:
                     return "[Notice]";
              case LOG_INFO:
                     return "[Info]";
              case LOG_DEBUG:
                     return "[Debug]";
              default:
                     break;
              }
              
              return "[Unknown]";
              
       }

       // stream stuff
       
}

---