(file) Return to Logger.cpp CVS log (file) (dir) Up to [Pegasus] / pegasus / src / Pegasus / Common

Diff for /pegasus/src/Pegasus/Common/Logger.cpp between version 1.22 and 1.42.2.1

version 1.22, 2002/08/29 00:27:52 version 1.42.2.1, 2006/02/10 16:09:37
Line 1 
Line 1 
 //%/////////////////////////////////////////////////////////////////////////////  //%2006////////////////////////////////////////////////////////////////////////
 // //
 // Copyright (c) 2000, 2001, 2002 BMC Software, Hewlett-Packard Company, IBM,  // Copyright (c) 2000, 2001, 2002 BMC Software; Hewlett-Packard Development
 // The Open Group, Tivoli Systems  // Company, L.P.; IBM Corp.; The Open Group; Tivoli Systems.
   // Copyright (c) 2003 BMC Software; Hewlett-Packard Development Company, L.P.;
   // IBM Corp.; EMC Corporation, The Open Group.
   // Copyright (c) 2004 BMC Software; Hewlett-Packard Development Company, L.P.;
   // IBM Corp.; EMC Corporation; VERITAS Software Corporation; The Open Group.
   // Copyright (c) 2005 Hewlett-Packard Development Company, L.P.; IBM Corp.;
   // EMC Corporation; VERITAS Software Corporation; The Open Group.
   // Copyright (c) 2006 Hewlett-Packard Development Company, L.P.; IBM Corp.;
   // EMC Corporation; Symantec Corporation; The Open Group.
 // //
 // Permission is hereby granted, free of charge, to any person obtaining a copy // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to // of this software and associated documentation files (the "Software"), to
Line 25 
Line 33 
 // //
 // Modified By: Sushma Fernandes (Hewlett-Packard Company) // Modified By: Sushma Fernandes (Hewlett-Packard Company)
 //              sushma_fernandes@hp.com //              sushma_fernandes@hp.com
   // Modified By: Dave Rosckes (IBM)
   //              rosckes@us.ibm.com
   //              Amit K Arora, IBM (amita@in.ibm.com) for PEP101
 // //
 //%///////////////////////////////////////////////////////////////////////////// //%/////////////////////////////////////////////////////////////////////////////
  
 #include <iostream> #include <iostream>
 #include <fstream> #include <fstream>
 #include "System.h"  #include <cstring>
 #include "Logger.h" #include "Logger.h"
 #include "System.h" #include "System.h"
 #include "Destroyer.h"  #include <Pegasus/Common/MessageLoader.h> //l10n
   
 #ifdef PEGASUS_OS_HPUX  
     #include <syslog.h>  
 #endif  
  
 PEGASUS_USING_STD; PEGASUS_USING_STD;
  
Line 49 
Line 56 
 const Uint32 Logger::SEVERE = (1 << 3); const Uint32 Logger::SEVERE = (1 << 3);
 const Uint32 Logger::FATAL = (1 << 4); const Uint32 Logger::FATAL = (1 << 4);
  
   static char const* LOGLEVEL_LIST[] =
   {
       "TRACE",
       "INFORMATION",
       "WARNING",
       "SEVERE",
       "FATAL"
   };
   
 LoggerRep* Logger::_rep = 0; LoggerRep* Logger::_rep = 0;
 String Logger::_homeDirectory = "."; String Logger::_homeDirectory = ".";
  
 // FUTURE-SF-P3-20020517 : This may need to be configurable. At least needs  const Uint32 Logger::_NUM_LOGLEVEL = 5;
 // to be set to 0xFF by default always.  
 Uint32 Logger::_severityMask = 0xFF;      // Set all on by default  // Set separator
   const char Logger::_SEPARATOR = '@';
   
   Uint32 Logger::_severityMask;
  
 Uint32 Logger::_writeControlMask = 0xF;   // Set all on by default Uint32 Logger::_writeControlMask = 0xF;   // Set all on by default
  
   // Set the return codes
   const Boolean Logger::_SUCCESS = 1;
   const Boolean Logger::_FAILURE = 0;
   
 /* _allocLogFileName. Allocates the name from a name set. /* _allocLogFileName. Allocates the name from a name set.
     Today this is static.  However, it should be completely     Today this is static.  However, it should be completely
     configerable and driven from the config file so that     configerable and driven from the config file so that
Line 99 
Line 122 
  
     LoggerRep(const String& homeDirectory)     LoggerRep(const String& homeDirectory)
     {     {
 #ifndef PEGASUS_OS_HPUX  #if !defined(PEGASUS_USE_SYSLOGS)
         // Add test for home directory set.         // Add test for home directory set.
  
         // If home directory does not exist, create it.         // If home directory does not exist, create it.
Line 110 
Line 133 
  
         // KS: I put the second test in just in case some trys to create         // KS: I put the second test in just in case some trys to create
         // a completly erronous directory.  At least we will get a message         // a completly erronous directory.  At least we will get a message
         if (!System::isDirectory(lgDir))          if (!System::isDirectory(lgDir)){
             cerr << "Logging Disabled";             //l10n
              //cerr << "Logging Disabled";
              MessageLoaderParms parms("Common.Logger.LOGGING_DISABLED",
                  "Logging Disabled");
   
              cerr << MessageLoader::getMessage(parms);
           }
  
         CString fileName = _allocLogFileName(homeDirectory, Logger::TRACE_LOG);         CString fileName = _allocLogFileName(homeDirectory, Logger::TRACE_LOG);
         _logs[Logger::TRACE_LOG].open(fileName, ios::app);         _logs[Logger::TRACE_LOG].open(fileName, ios::app);
Line 132 
Line 161 
     {     {
         int index = int(logFileType);         int index = int(logFileType);
  
         if (index > int(Logger::ERROR_LOG))          if (index > int(Logger::NUM_LOGS))
             index = Logger::ERROR_LOG;             index = Logger::ERROR_LOG;
  
         return _logs[index];         return _logs[index];
Line 143 
Line 172 
     ofstream _logs[int(Logger::NUM_LOGS)];     ofstream _logs[int(Logger::NUM_LOGS)];
 }; };
  
 void Logger::put(  void Logger::_putInternal(
     LogFileType logFileType,     LogFileType logFileType,
     const String& systemId,     const String& systemId,
     Uint32 severity,      const Uint32 logComponent, // TODO: Support logComponent mask in future release
       Uint32 logLevel,
     const String& formatString,     const String& formatString,
       const String& messageId,  // l10n
     const Formatter::Arg& arg0,     const Formatter::Arg& arg0,
     const Formatter::Arg& arg1,     const Formatter::Arg& arg1,
     const Formatter::Arg& arg2,     const Formatter::Arg& arg2,
Line 159 
Line 190 
     const Formatter::Arg& arg8,     const Formatter::Arg& arg8,
     const Formatter::Arg& arg9)     const Formatter::Arg& arg9)
 { {
     // Test for severity against severity mask to determine      // Test for logLevel against severity mask to determine
     // if we write this log.     // if we write this log.
     if ((_severityMask & severity) != 0)      if ((_severityMask & logLevel) != 0)
     {     {
         if (!_rep)         if (!_rep)
            _rep = new LoggerRep(_homeDirectory);            _rep = new LoggerRep(_homeDirectory);
  
         // Get the Severity String          // Get the logLevel String
         // This converts bitmap to string based on highest order         // This converts bitmap to string based on highest order
         // bit set         // bit set
         // ATTN: KS Fix this more efficiently.         // ATTN: KS Fix this more efficiently.
Line 181 
Line 212 
         // NUM_LEVELS = 5         // NUM_LEVELS = 5
         int sizeSvNames = sizeof(svNames) / sizeof(svNames[0]) - 1;         int sizeSvNames = sizeof(svNames) / sizeof(svNames[0]) - 1;
  
         String logMsg = Formatter::format(formatString,  // l10n start
           // The localized message to be sent to the system log.
           String localizedMsg;
   
           // If the caller specified a messageId, then load the localized
           // message in the locale of the server process.
           if (messageId != String::EMPTY)
           {
               // A message ID was specified.  Use the MessageLoader.
               MessageLoaderParms msgParms(messageId, formatString);
               msgParms.useProcessLocale = true;
               msgParms.arg0 = arg0;
               msgParms.arg1 = arg1;
               msgParms.arg2 = arg2;
               msgParms.arg3 = arg3;
               msgParms.arg4 = arg4;
               msgParms.arg5 = arg5;
               msgParms.arg6 = arg6;
               msgParms.arg7 = arg7;
               msgParms.arg8 = arg8;
               msgParms.arg9 = arg9;
   
               localizedMsg = MessageLoader::getMessage(msgParms);
           }
           else
           {  // No message ID.  Use the Pegasus formatter
                 localizedMsg = Formatter::format(formatString,
                 arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);                 arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
           }
   // l10n end
  
         #ifdef PEGASUS_OS_HPUX  #if defined(PEGASUS_USE_SYSLOGS)
             // FUTURE-SF-P3-20020517 : Use the Syslog on HP-UX. Eventually only  
             // certain messages will go to the Syslog and others to the  
             // Pegasus Logger.  
             Uint32 syslogLevel = LOG_DEBUG;  
   
             // Map the log levels.  
             if (severity & Logger::TRACE) syslogLevel =       LOG_DEBUG;  
             if (severity & Logger::INFORMATION) syslogLevel = LOG_INFO;  
             if (severity & Logger::WARNING) syslogLevel =     LOG_WARNING;  
             if (severity & Logger::SEVERE) syslogLevel =      LOG_ERR;  
             if (severity & Logger::FATAL) syslogLevel =       LOG_CRIT;  
   
             // Open the syslog.  
             // Ignore the systemId and open the log as cimserver  
             openlog("cimserver", LOG_PID|LOG_CONS, LOG_DAEMON);  
  
             // Log the message             // Log the message
             syslog(syslogLevel, "%s", (const char*)logMsg.getCString());          System::syslog(System::CIMSERVER, logLevel, localizedMsg.getCString());
  
             // Close the syslog.  
             closelog();  
        #else        #else
   
           // Prepend the systemId to the incoming message
           String messageString(systemId);
           messageString.append(": ");
           messageString.append(localizedMsg);  // l10n
   
             const char* tmp = "";             const char* tmp = "";
             if (severity & Logger::TRACE) tmp =       "TRACE   ";          if (logLevel & Logger::TRACE) tmp =       "TRACE   ";
             if (severity & Logger::INFORMATION) tmp = "INFO    ";          if (logLevel & Logger::INFORMATION) tmp = "INFO    ";
             if (severity & Logger::WARNING) tmp =     "WARNING ";          if (logLevel & Logger::WARNING) tmp =     "WARNING ";
             if (severity & Logger::SEVERE) tmp =      "SEVERE  ";          if (logLevel & Logger::SEVERE) tmp =      "SEVERE  ";
             if (severity & Logger::FATAL) tmp =       "FATAL   ";          if (logLevel & Logger::FATAL) tmp =       "FATAL   ";
   
                 _rep->logOf(logFileType) << System::getCurrentASCIITime()                 _rep->logOf(logFileType) << System::getCurrentASCIITime()
                  << " " << tmp << logMsg << endl;             << " " << tmp << (const char *)messageString.getCString() << endl;
   
        #endif        #endif
       }
   }
   
   ////////////////////////////////////////////////////////////////////////////////
   //
   // Public methods start here:
   //
   ////////////////////////////////////////////////////////////////////////////////
   
   void Logger::put(
       LogFileType logFileType,
       const String& systemId,
       Uint32 logLevel,
       const String& formatString,
       const Formatter::Arg& arg0,
       const Formatter::Arg& arg1,
       const Formatter::Arg& arg2,
       const Formatter::Arg& arg3,
       const Formatter::Arg& arg4,
       const Formatter::Arg& arg5,
       const Formatter::Arg& arg6,
       const Formatter::Arg& arg7,
       const Formatter::Arg& arg8,
       const Formatter::Arg& arg9)
   {
       if (wouldLog(logLevel))
       {
           Logger::_putInternal(logFileType, systemId, 0, logLevel,
               formatString, String::EMPTY, arg0, arg1, arg2, arg3,
               arg4, arg5, arg6, arg7, arg8, arg9);
       }
   }
  
   void Logger::put(
       LogFileType logFileType,
       const String& systemId,
       Uint32 logLevel,
       const String& formatString)
   {
       if (wouldLog(logLevel))
       {
           Logger::_putInternal(logFileType, systemId, 0, logLevel,
               formatString, String::EMPTY);
     }     }
 } }
  
 void Logger::clean(const String& directory)  void Logger::put(
       LogFileType logFileType,
       const String& systemId,
       Uint32 logLevel,
       const String& formatString,
       const Formatter::Arg& arg0)
   {
       if (wouldLog(logLevel))
 { {
     //String logFiles = logsDirectory;          Logger::_putInternal(logFileType, systemId, 0, logLevel,
     //logFiles.append("/PegasusTrace.log");              formatString, String::EMPTY, arg0);
     //cout << "Delete logs in " << logFiles << endl;      }
     //System::removeFile(logFiles.getCString());  }
     //for (i = xx; i < yy; i++)  
     //(  void Logger::put(
     //_allocateLogFileName(directory, i)      LogFileType logFileType,
     //removeFile(      const String& systemId,
     //}      Uint32 logLevel,
       const String& formatString,
       const Formatter::Arg& arg0,
       const Formatter::Arg& arg1)
   {
       if (wouldLog(logLevel))
       {
           Logger::_putInternal(logFileType, systemId, 0, logLevel,
               formatString, String::EMPTY, arg0, arg1);
       }
   }
   
   void Logger::put(
       LogFileType logFileType,
       const String& systemId,
       Uint32 logLevel,
       const String& formatString,
       const Formatter::Arg& arg0,
       const Formatter::Arg& arg1,
       const Formatter::Arg& arg2)
   {
       if (wouldLog(logLevel))
       {
           Logger::_putInternal(logFileType, systemId, 0, logLevel,
               formatString, String::EMPTY, arg0, arg1, arg2);
       }
   }
   
   void Logger::put_l(
       LogFileType logFileType,
       const String& systemId,
       Uint32 logLevel,
       const String& messageId,
       const String& formatString,
       const Formatter::Arg& arg0,
       const Formatter::Arg& arg1,
       const Formatter::Arg& arg2,
       const Formatter::Arg& arg3,
       const Formatter::Arg& arg4,
       const Formatter::Arg& arg5,
       const Formatter::Arg& arg6,
       const Formatter::Arg& arg7,
       const Formatter::Arg& arg8,
       const Formatter::Arg& arg9)
   {
       if (wouldLog(logLevel))
       {
           Logger::_putInternal(logFileType, systemId, 0, logLevel,
               formatString, messageId, arg0, arg1, arg2, arg3, arg4, arg5,
               arg6, arg7, arg8, arg9);
       }
   }
   
   void Logger::put_l(
        LogFileType logFileType,
        const String& systemId,
        Uint32 logLevel,
        const String& messageId,
        const String& formatString)
   {
       if (wouldLog(logLevel))
       {
           Logger::_putInternal(logFileType, systemId, 0, logLevel,
           formatString, messageId);
       }
   }
   
   void Logger::put_l(
        LogFileType logFileType,
        const String& systemId,
        Uint32 logLevel,
        const String& messageId,
        const String& formatString,
        const Formatter::Arg& arg0)
   {
       if (wouldLog(logLevel))
       {
           Logger::_putInternal(logFileType, systemId, 0, logLevel,
               formatString, messageId, arg0);
       }
   }
   
   void Logger::put_l(
        LogFileType logFileType,
        const String& systemId,
        Uint32 logLevel,
        const String& messageId,
        const String& formatString,
        const Formatter::Arg& arg0,
        const Formatter::Arg& arg1)
   {
       if (wouldLog(logLevel))
       {
           Logger::_putInternal(logFileType, systemId, 0, logLevel,
               formatString, messageId, arg0, arg1);
       }
   }
   
   void Logger::put_l(
        LogFileType logFileType,
        const String& systemId,
        Uint32 logLevel,
        const String& messageId,
        const String& formatString,
        const Formatter::Arg& arg0,
        const Formatter::Arg& arg1,
        const Formatter::Arg& arg2)
   {
       if (wouldLog(logLevel))
       {
           Logger::_putInternal(logFileType, systemId, 0, logLevel,
               formatString, messageId, arg0, arg1, arg2);
       }
   }
   
   void Logger::trace(
       LogFileType logFileType,
       const String& systemId,
       const Uint32 logComponent,
       const String& formatString,
       const Formatter::Arg& arg0,
       const Formatter::Arg& arg1,
       const Formatter::Arg& arg2,
       const Formatter::Arg& arg3,
       const Formatter::Arg& arg4,
       const Formatter::Arg& arg5,
       const Formatter::Arg& arg6,
       const Formatter::Arg& arg7,
       const Formatter::Arg& arg8,
       const Formatter::Arg& arg9)
   {
       if (wouldLog(Logger::TRACE))
       {
           Logger::_putInternal(logFileType, systemId, logComponent, Logger::TRACE,
               formatString, String::EMPTY, arg0, arg1, arg2, arg3, arg4, arg5,
               arg6, arg7, arg8, arg9);
       }
   }
   
   void Logger::trace(
       LogFileType logFileType,
       const String& systemId,
       const Uint32 logComponent,
       const String& formatString)
   {
       if (wouldLog(Logger::TRACE))
       {
           Logger::_putInternal(logFileType, systemId, logComponent, Logger::TRACE,
               formatString, String::EMPTY);
       }
   }
   
   void Logger::trace(
       LogFileType logFileType,
       const String& systemId,
       const Uint32 logComponent,
       const String& formatString,
       const Formatter::Arg& arg0)
   {
       if (wouldLog(Logger::TRACE))
       {
           Logger::_putInternal(logFileType, systemId, logComponent, Logger::TRACE,
               formatString, String::EMPTY, arg0);
       }
   }
   
   void Logger::trace(
       LogFileType logFileType,
       const String& systemId,
       const Uint32 logComponent,
       const String& formatString,
       const Formatter::Arg& arg0,
       const Formatter::Arg& arg1)
   {
       if (wouldLog(Logger::TRACE))
       {
           Logger::_putInternal(logFileType, systemId, logComponent, Logger::TRACE,
               formatString, String::EMPTY, arg0, arg1);
       }
   }
   
   void Logger::trace(
       LogFileType logFileType,
       const String& systemId,
       const Uint32 logComponent,
       const String& formatString,
       const Formatter::Arg& arg0,
       const Formatter::Arg& arg1,
       const Formatter::Arg& arg2)
   {
       if (wouldLog(Logger::TRACE))
       {
           Logger::_putInternal(logFileType, systemId, logComponent, Logger::TRACE,
               formatString, String::EMPTY, arg0, arg1, arg2);
       }
   }
   
   void Logger::trace_l(
       LogFileType logFileType,
       const String& systemId,
       const Uint32 logComponent,
       const String& messageId,
       const String& formatString,
       const Formatter::Arg& arg0,
       const Formatter::Arg& arg1,
       const Formatter::Arg& arg2,
       const Formatter::Arg& arg3,
       const Formatter::Arg& arg4,
       const Formatter::Arg& arg5,
       const Formatter::Arg& arg6,
       const Formatter::Arg& arg7,
       const Formatter::Arg& arg8,
       const Formatter::Arg& arg9)
   {
       if (wouldLog(Logger::TRACE))
       {
           Logger::_putInternal(logFileType, systemId, logComponent, Logger::TRACE,
               formatString, messageId, arg0, arg1, arg2, arg3, arg4, arg5, arg6,
               arg7, arg8, arg9);
       }
   }
   
   void Logger::trace_l(
       LogFileType logFileType,
       const String& systemId,
       const Uint32 logComponent,
       const String& messageId,
       const String& formatString)
   {
       if (wouldLog(Logger::TRACE))
       {
           Logger::_putInternal(logFileType, systemId, logComponent, Logger::TRACE,
               formatString, messageId);
       }
   }
   
   void Logger::trace_l(
       LogFileType logFileType,
       const String& systemId,
       const Uint32 logComponent,
       const String& messageId,
       const String& formatString,
       const Formatter::Arg& arg0)
   {
       if (wouldLog(Logger::TRACE))
       {
           Logger::_putInternal(logFileType, systemId, logComponent, Logger::TRACE,
               formatString, messageId, arg0);
       }
   }
   
   void Logger::trace_l(
       LogFileType logFileType,
       const String& systemId,
       const Uint32 logComponent,
       const String& messageId,
       const String& formatString,
       const Formatter::Arg& arg0,
       const Formatter::Arg& arg1)
   {
       if (wouldLog(Logger::TRACE))
       {
           Logger::_putInternal(logFileType, systemId, logComponent, Logger::TRACE,
               formatString, messageId, arg0, arg1);
       }
   }
   
   void Logger::trace_l(
       LogFileType logFileType,
       const String& systemId,
       const Uint32 logComponent,
       const String& messageId,
       const String& formatString,
       const Formatter::Arg& arg0,
       const Formatter::Arg& arg1,
       const Formatter::Arg& arg2)
   {
       if (wouldLog(Logger::TRACE))
       {
           Logger::_putInternal(logFileType, systemId, logComponent, Logger::TRACE,
               formatString, messageId, arg0, arg1, arg2);
       }
 } }
  
 void Logger::setHomeDirectory(const String& homeDirectory) void Logger::setHomeDirectory(const String& homeDirectory)
Line 238 
Line 618 
     _homeDirectory = homeDirectory;     _homeDirectory = homeDirectory;
 } }
  
   void Logger::setlogLevelMask( const String logLevelList )
   {
       Uint32 position          = 0;
       Uint32 logLevelType = 0;
       String logLevelName      = logLevelList;
   
       // Check if logLevel has been specified
       if (logLevelName != String::EMPTY)
       {
           // initialise _severityMask
           _severityMask = 0;
   
           // Set logLevelType to indicate the level of logging
           // required by the user.
           if (String::equalNoCase(logLevelName,"TRACE"))
           {
               logLevelType =  Logger::TRACE;
           }
           else if (String::equalNoCase(logLevelName,"INFORMATION"))
           {
               logLevelType =  Logger::INFORMATION;
           }
           else if (String::equalNoCase(logLevelName,"WARNING"))
           {
               logLevelType = Logger::WARNING;
           }
           else if (String::equalNoCase(logLevelName,"SEVERE"))
           {
               logLevelType = Logger::SEVERE;
           }
           else if (String::equalNoCase(logLevelName,"FATAL"))
           {
               logLevelType = Logger::FATAL;
           }
           // Setting _severityMask.  NOTE:  When adding new logLevels
           // it is essential that they are adding in ascending order
           // based on priority.  Once a case statement is true we will
           // continue to set all following log levels with a higher
           // priority.
           switch(logLevelType)
           {
               case Logger::TRACE:
                     _severityMask |= Logger::TRACE;
               case Logger::INFORMATION:
                     _severityMask |= Logger::INFORMATION;
               case Logger::WARNING:
                     _severityMask |= Logger::WARNING;
               case Logger::SEVERE:
                     _severityMask |= Logger::SEVERE;
               case Logger::FATAL:
                     _severityMask |= Logger::FATAL;
           }
       }
       else
       {
           // Property logLevel not specified, set default value.
           _severityMask = ~Logger::TRACE;
       }
       return ;
   }
   
   Boolean Logger::isValidlogLevel(const String logLevel)
   {
       // Validate the logLevel and modify the logLevel argument
       // to reflect the invalid logLevel
   
       Uint32    position=0;
       Uint32    index=0;
       String    logLevelName = String::EMPTY;
       Boolean   validlogLevel=false;
       Boolean   retCode=true;
   
       logLevelName = logLevel;
   
       if (logLevelName != String::EMPTY)
       {
           // Lookup the index for logLevel name in _logLevel_LIST
           index = 0;
           validlogLevel = false;
   
           while (index < _NUM_LOGLEVEL)
           {
               if (String::equalNoCase(logLevelName, LOGLEVEL_LIST[index]))
               {
                   // Found logLevel, break from the loop
                   validlogLevel = true;
                   break;
               }
               else
               {
                   index++;
               }
           }
       }
       else
       {
           // logLevels is empty, it is a valid value so return true
           return _SUCCESS;
       }
   
       return validlogLevel;
   }
   
 PEGASUS_NAMESPACE_END PEGASUS_NAMESPACE_END

Legend:
Removed from v.1.22  
changed lines
  Added in v.1.42.2.1
No CVS admin address has been configured
 Powered by
ViewCVS 0.9.2