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

Diff for /pegasus/src/Pegasus/Common/Tracer.cpp between version 1.40 and 1.40.4.2

version 1.40, 2006/11/10 18:14:58 version 1.40.4.2, 2007/05/25 17:39:01
Line 35 
Line 35 
 #include <Pegasus/Common/Tracer.h> #include <Pegasus/Common/Tracer.h>
 #include <Pegasus/Common/Thread.h> #include <Pegasus/Common/Thread.h>
 #include <Pegasus/Common/System.h> #include <Pegasus/Common/System.h>
   #include <Pegasus/Common/HTTPMessage.h>
  
 PEGASUS_USING_STD; PEGASUS_USING_STD;
  
Line 110 
Line 111 
 //////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
 void Tracer::_trace( void Tracer::_trace(
     const Uint32 traceComponent,     const Uint32 traceComponent,
     const Uint32 traceLevel,  
     const char* fmt,     const char* fmt,
     va_list argList)     va_list argList)
 { {
     if (traceLevel == LEVEL1)  
     {  
         trace(traceComponent, Tracer::LEVEL4, "%s", _LOG_MSG);  
     }  
     else  
     {  
         if (_isTraceEnabled(traceComponent, traceLevel))  
         {  
             _trace(traceComponent, "", fmt, argList);             _trace(traceComponent, "", fmt, argList);
         }         }
     }  
 }  
  
 //////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
 //Traces the given message - Overloaded for including FileName and Line number //Traces the given message - Overloaded for including FileName and Line number
Line 134 
Line 124 
     const char* fileName,     const char* fileName,
     const Uint32 lineNum,     const Uint32 lineNum,
     const Uint32 traceComponent,     const Uint32 traceComponent,
     const Uint32 traceLevel,  
     const char* fmt,     const char* fmt,
     va_list argList)     va_list argList)
 { {
     char* message;     char* message;
   
     if (traceLevel == LEVEL1)  
     {  
         trace(traceComponent, Tracer::LEVEL4, "%s", _LOG_MSG);  
     }  
     else  
     {  
         if (_isTraceEnabled(traceComponent,traceLevel))  
         {  
             //             //
             // Allocate memory for the message string             // Allocate memory for the message string
             // Needs to be updated if additional info is added             // Needs to be updated if additional info is added
Line 165 
Line 145 
             _trace(traceComponent, message, fmt, argList);             _trace(traceComponent, message, fmt, argList);
             delete [] message;             delete [] message;
         }         }
     }  
 }  
   
 ////////////////////////////////////////////////////////////////////////////////  
 //Traces the given buffer  
 ////////////////////////////////////////////////////////////////////////////////  
 void Tracer::_traceBuffer(  
     const Uint32 traceComponent,  
     const Uint32 traceLevel,  
     const char*  data,  
     const Uint32 size)  
 {  
     if (traceLevel == LEVEL1)  
     {  
         trace(traceComponent, Tracer::LEVEL4, "%s", _LOG_MSG);  
     }  
     else  
     {  
         if (_isTraceEnabled(traceComponent, traceLevel))  
         {  
             char* tmpBuf = new char[size+1];  
   
             strncpy(tmpBuf, data, size);  
             tmpBuf[size] = '\0';  
             trace(traceComponent, traceLevel, "%s", tmpBuf);  
   
             delete [] tmpBuf;  
         }  
     }  
 }  
 ////////////////////////////////////////////////////////////////////////////////  
 //Traces the given buffer - Overloaded for including FileName and Line number  
 ////////////////////////////////////////////////////////////////////////////////  
 void Tracer::_traceBuffer(  
     const char* fileName,  
     const Uint32 lineNum,  
     const Uint32 traceComponent,  
     const Uint32 traceLevel,  
     const char*  data,  
     const Uint32 size)  
 {  
     if (traceLevel == LEVEL1)  
     {  
         trace(traceComponent, Tracer::LEVEL4, "%s", _LOG_MSG);  
     }  
     else  
     {  
         if (_isTraceEnabled(traceComponent, traceLevel))  
         {  
             char* tmpBuf = new char[size+1];  
   
             strncpy( tmpBuf, data, size );  
             tmpBuf[size] = '\0';  
             trace(fileName, lineNum, traceComponent, traceLevel, "%s", tmpBuf);  
   
             delete [] tmpBuf;  
         }  
     }  
 }  
   
 ////////////////////////////////////////////////////////////////////////////////  
 //Traces the given string  
 ////////////////////////////////////////////////////////////////////////////////  
 void Tracer::_traceString(  
     const Uint32 traceComponent,  
     const Uint32 traceLevel,  
     const String& traceString)  
 {  
     if (traceLevel == LEVEL1)  
     {  
         trace(traceComponent, Tracer::LEVEL4, "%s", _LOG_MSG);  
     }  
     else  
     {  
         if (_isTraceEnabled(traceComponent,traceLevel))  
         {  
             trace(traceComponent, traceLevel, "%s",  
                        (const char *)traceString.getCString());  
         }  
     }  
 }  
  
 //////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
 //Traces the given string - Overloaded to include the fileName and line number //Traces the given string - Overloaded to include the fileName and line number
 //of trace origin. //of trace origin.
 //////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
 void Tracer::_traceString(  void Tracer::_traceCString(
     const char* fileName,     const char* fileName,
     const Uint32 lineNum,     const Uint32 lineNum,
     const Uint32 traceComponent,     const Uint32 traceComponent,
     const Uint32 traceLevel,      const char* cstring)
     const String& traceString)  
 {  
     if (traceLevel == LEVEL1)  
     {     {
         trace(traceComponent, Tracer::LEVEL4, "%s", _LOG_MSG);      char* message;
     }  
     else      //
     {      // Allocate memory for the message string
         if (_isTraceEnabled(traceComponent, traceLevel))      // Needs to be updated if additional info is added
         {      //
             trace(fileName, lineNum, traceComponent, traceLevel, "%s",      message = new char[strlen(fileName) +
                      (const char *)traceString.getCString());          _STRLEN_MAX_UNSIGNED_INT + (_STRLEN_MAX_PID_TID * 2) + 8];
         }      sprintf(
     }         message,
          "[%d:%s:%s:%u]: ",
          System::getPID(),
          Threads::id().buffer,
          fileName,
          lineNum);
   
       _traceCString(traceComponent, message, cstring);
       delete [] message;
 } }
  
 //////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
Line 277 
Line 181 
 //////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
 void Tracer::_traceCIMException( void Tracer::_traceCIMException(
     const Uint32 traceComponent,     const Uint32 traceComponent,
     const Uint32 traceLevel,  
     const CIMException& cimException)     const CIMException& cimException)
 { {
     if (traceLevel == LEVEL1)  
     {  
         trace(traceComponent, Tracer::LEVEL4, "%s", _LOG_MSG);  
     }  
     else  
     {  
         if (_isTraceEnabled(traceComponent, traceLevel))  
         {  
             // get the CIMException trace message string             // get the CIMException trace message string
             String traceMsg =         CString traceMsg = TraceableCIMException(cimException).getTraceDescription().getCString();
                 TraceableCIMException(cimException).getTraceDescription();  
   
             // trace the string             // trace the string
             _traceString(traceComponent, traceLevel, traceMsg);         _traceCString(traceComponent, "", (const char*) traceMsg);
         }  
     }  
 } }
  
 ////////////////////////////////////////////////////////////////////////////////  char* Tracer::getHTTPRequestMessage(
 //Traces method entry      const Buffer& requestMessage)
 ////////////////////////////////////////////////////////////////////////////////  
 void Tracer::_traceEnter(  
     const char* fileName,  
     const Uint32 lineNum,  
     const Uint32 traceComponent,  
     const char* fmt,  
     ...)  
 {  
     va_list argList;  
     char* message;  
   
     if (_isTraceEnabled(traceComponent, LEVEL1))  
     {     {
       const Uint32 requestSize = requestMessage.size();
  
         va_start(argList, fmt);      // Make a copy of the request message.
       AutoArrayPtr<char> requestBuf(new char [requestSize + 1]);
       strncpy(requestBuf.get(), requestMessage.getData(), requestSize);
       requestBuf.get()[requestSize] = 0;
  
         //         //
         // Allocate memory for the message string      // Check if requestBuffer contains a Basic authorization header.
         // Needs to be updated if additional info is added      // If true, suppress the user/passwd info in the request buffer.
         //         //
         message = new char[ strlen(fileName) +      char* sep;
             _STRLEN_MAX_UNSIGNED_INT + (_STRLEN_MAX_PID_TID * 2) + 8 ];      const char* line = requestBuf.get();
  
         sprintf(      while ((sep = HTTPMessage::findSeparator(
            message,          line, (Uint32)(requestSize - (line - requestBuf.get())))) &&
            "[%d:%s:%s:%u]: ",          (line != sep))
            System::getPID(),      {
            Threads::id().buffer,          if (HTTPMessage::expectHeaderToken(line, "Authorization") &&
            fileName,               HTTPMessage::expectHeaderToken(line, ":") &&
            lineNum);               HTTPMessage::expectHeaderToken(line, "Basic"))
           {
               // Suppress the user/passwd info
               HTTPMessage::skipHeaderWhitespace(line);
               for ( char* userpass = (char*)line ;
                   userpass < sep;
                   *userpass = 'X', userpass++);
  
         _trace(traceComponent, message, fmt, argList);              break;
           }
  
         va_end(argList);          line = sep + ((*sep == '\r') ? 2 : 1);
         delete [] message;  
     }     }
   
       return requestBuf.release();
 } }
  
 //////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
 //Traces method exit  //Traces method entry and exit
 //////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
 void Tracer::_traceExit(  void Tracer::_traceMethod(
     const char* fileName,     const char* fileName,
     const Uint32 lineNum,     const Uint32 lineNum,
     const Uint32 traceComponent,     const Uint32 traceComponent,
     const char* fmt      const char* methodEntryExit,
     ...)      const char* method)
 { {
     va_list argList;  
     char* message;     char* message;
  
     if (_isTraceEnabled(traceComponent, LEVEL1))  
     {  
         va_start(argList, fmt);  
   
         //         //
         // Allocate memory for the message string         // Allocate memory for the message string
         // Needs to be updated if additional info is added         // Needs to be updated if additional info is added
         //         //
       // assume Method entry/exit string 15 characters long
       // +1 space character
         message = new char[strlen(fileName) +         message = new char[strlen(fileName) +
             _STRLEN_MAX_UNSIGNED_INT + (_STRLEN_MAX_PID_TID * 2) + 8];          _STRLEN_MAX_UNSIGNED_INT + (_STRLEN_MAX_PID_TID * 2) + 8
           + 16];
  
         sprintf(         sprintf(
            message,            message,
            "[%d:%s:%s:%u]: ",         "[%d:%s:%s:%u]: %s ",
            System::getPID(),            System::getPID(),
            Threads::id().buffer,            Threads::id().buffer,
            fileName,            fileName,
            lineNum);         lineNum,
          methodEntryExit);
  
         _trace(traceComponent, message, fmt, argList);      _traceCString(traceComponent, message, method);
         va_end(argList);  
  
         delete [] message;         delete [] message;
     }     }
 }  
  
 //////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
 //Checks if trace is enabled for the given component and level //Checks if trace is enabled for the given component and level
Line 394 
Line 283 
 } }
  
 //////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
 //Called by all trace interfaces to log message to trace file  //Called by all trace interfaces with variable arguments
   //to log message to trace file
 //////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
 void Tracer::_trace( void Tracer::_trace(
     const Uint32 traceComponent,     const Uint32 traceComponent,
Line 413 
Line 303 
     // Needs to be updated if additional info is added     // Needs to be updated if additional info is added
     //     //
  
   
   
     // Construct the message header     // Construct the message header
     // The message header is in the following format     // The message header is in the following format
     // timestamp: <component name> [file name:line number]     // timestamp: <component name> [file name:line number]
Line 432 
Line 320 
     else     else
     {     {
         //         //
         // Since the message is blank form a string using the pid and tid          // Since the message is blank, form a string using the pid and tid
         //         //
         char* tmpBuffer;         char* tmpBuffer;
  
Line 459 
Line 347 
 } }
  
 //////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
   //Called by all trace interfaces using a character string without format string
   //to log message to trace file
   ////////////////////////////////////////////////////////////////////////////////
   void Tracer::_traceCString(
       const Uint32 traceComponent,
       const char* message,
       const char* cstring)
   {
       char* completeMessage;
   
       // Get the current system time and prepend to message
       String currentTime = System::getCurrentASCIITime();
       CString timeStamp = currentTime.getCString();
       //
       // Allocate completeMessage.
       // Needs to be updated if additional info is added
       //
   
       // Construct the message header
       // The message header is in the following format
       // timestamp: <component name> [file name:line number]
       if (*message != '\0')
       {
          // << Wed Jul 16 10:58:40 2003 mdd >> _STRLEN_MAX_PID_TID is not used
          // in this format string
          completeMessage = new char [strlen(message) +
              strlen(TRACE_COMPONENT_LIST[traceComponent]) +
              strlen(timeStamp) + _STRLEN_MAX_PID_TID + 5 +
              strlen(cstring) ];
   
           sprintf(completeMessage, "%s: %s %s%s", (const char*)timeStamp,
               TRACE_COMPONENT_LIST[traceComponent], message, cstring);
       }
       else
       {
           //
           // Since the message is blank, form a string using the pid and tid
           //
           char* tmpBuffer;
   
           //
           // Allocate messageHeader.
           // Needs to be updated if additional info is added
           //
           tmpBuffer = new char[2 * _STRLEN_MAX_PID_TID + 6];
           sprintf(tmpBuffer, "[%u:%s]: ",
               System::getPID(), Threads::id().buffer);
   
           completeMessage = new char[strlen(timeStamp) +
               strlen(TRACE_COMPONENT_LIST[traceComponent]) +
               strlen(tmpBuffer) + 1  + 5 +
               strlen(cstring)];
   
           sprintf(completeMessage, "%s: %s %s %s", (const char*)timeStamp,
               TRACE_COMPONENT_LIST[traceComponent], tmpBuffer, cstring);
           delete [] tmpBuffer;
       }
   
       // Call trace file handler to write message
       _getInstance()->_traceHandler->handleMessage(completeMessage);
   
       delete [] completeMessage;
   }
   
   
   ////////////////////////////////////////////////////////////////////////////////
 //Validate the trace file //Validate the trace file
 //////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
 Boolean Tracer::isValidFileName(const char* filePath) Boolean Tracer::isValidFileName(const char* filePath)
Line 729 
Line 683 
  
 void Tracer::traceEnter( void Tracer::traceEnter(
     TracerToken& token,     TracerToken& token,
     Uint32 traceComponent,  
     const char* method)  
 {  
     if (_traceOn)  
     {  
         token.component = traceComponent;  
         token.method = method;  
   
         _traceEnter(  
             "unknown", 0, traceComponent, "%s %s", _METHOD_ENTER_MSG, method);  
     }  
 }  
   
 void Tracer::traceExit(TracerToken& token)  
 {  
     if (_traceOn)  
         _traceExit(  
             "unknown",0, token.component, "%s %s",  
             _METHOD_EXIT_MSG, token.method);  
 }  
   
 void Tracer::traceEnter(  
     TracerToken& token,  
     const char* file,     const char* file,
     size_t line,     size_t line,
     Uint32 traceComponent,     Uint32 traceComponent,
     const char* method)     const char* method)
 { {
     if (_traceOn)  
     {  
         token.component = traceComponent;         token.component = traceComponent;
         token.method = method;         token.method = method;
  
         _traceEnter(      if (_isTraceEnabled(traceComponent, LEVEL1))
             file, line, traceComponent, "%s %s", _METHOD_ENTER_MSG, method);      {
           _traceMethod(
               file, (Uint32)line, traceComponent,
               _METHOD_ENTER_MSG, method);
     }     }
 } }
  
Line 772 
Line 704 
     const char* file,     const char* file,
     size_t line)     size_t line)
 { {
     if (_traceOn)      if (_isTraceEnabled(token.component, LEVEL1))
         _traceExit(          _traceMethod(
             file, line, token.component, "%s %s",              file, (Uint32)line, token.component,
             _METHOD_EXIT_MSG, token.method);             _METHOD_EXIT_MSG, token.method);
 } }
  
 void Tracer::traceBuffer(  
     const Uint32 traceComponent,  
     const Uint32 traceLevel,  
     const char*  data,  
     const Uint32 size)  
 {  
     if (_traceOn)  
         _traceBuffer(traceComponent, traceLevel, data, size);  
 }  
   
 void Tracer::traceBuffer(  
     const char*  fileName,  
     const Uint32 lineNum,  
     const Uint32 traceComponent,  
     const Uint32 traceLevel,  
     const char*  data,  
     const Uint32 size)  
 {  
     if (_traceOn)  
     {  
         _traceBuffer(  
             fileName, lineNum, traceComponent, traceLevel, data, size);  
     }  
 }  
   
 void Tracer::trace( void Tracer::trace(
     const Uint32 traceComponent,     const Uint32 traceComponent,
     const Uint32 traceLevel,     const Uint32 traceLevel,
     const char *fmt,     const char *fmt,
     ...)     ...)
 { {
     if (_traceOn)      PEGASUS_ASSERT(traceLevel != LEVEL1);
       if (_isTraceEnabled(traceComponent, traceLevel))
     {     {
         va_list argList;         va_list argList;
   
         va_start(argList,fmt);         va_start(argList,fmt);
         _trace(traceComponent,traceLevel,fmt,argList);          _trace(traceComponent,fmt,argList);
         va_end(argList);         va_end(argList);
     }     }
 } }
Line 827 
Line 734 
     const char* fmt,     const char* fmt,
     ...)     ...)
 { {
     if (_traceOn)      PEGASUS_ASSERT(traceLevel != LEVEL1);
       if (_isTraceEnabled(traceComponent, traceLevel))
     {     {
         va_list argList;         va_list argList;
  
         va_start(argList,fmt);         va_start(argList,fmt);
         _trace(fileName,lineNum,traceComponent,traceLevel,fmt,argList);          _trace(fileName,lineNum,traceComponent,fmt,argList);
         va_end(argList);         va_end(argList);
     }     }
 } }
  
 void Tracer::trace(  void Tracer::traceString(
     const char* fileName,     const char* fileName,
     const Uint32 lineNum,     const Uint32 lineNum,
     const Uint32 traceComponent,     const Uint32 traceComponent,
     const Uint32 traceLevel,     const Uint32 traceLevel,
     const String& traceString)      const String& string)
 { {
     if (_traceOn)      PEGASUS_ASSERT(traceLevel != LEVEL1);
       if (_isTraceEnabled(traceComponent, traceLevel))
     {     {
         _traceString(          _traceCString(
             fileName, lineNum, traceComponent, traceLevel, traceString);              fileName, lineNum, traceComponent, (const char*) string.getCString());
     }     }
 } }
  
 void Tracer::traceCIMException(  void Tracer::traceCString(
       const char* fileName,
       const Uint32 lineNum,
     const Uint32 traceComponent,     const Uint32 traceComponent,
     const Uint32 traceLevel,     const Uint32 traceLevel,
     const CIMException& cimException)      const char* cstring)
 { {
     if (_traceOn)      PEGASUS_ASSERT(traceLevel != LEVEL1);
       if (_isTraceEnabled(traceComponent, traceLevel))
     {     {
         _traceCIMException(traceComponent, traceLevel, cimException);          _traceCString(
               fileName, lineNum, traceComponent, cstring);
     }     }
 } }
  
 void Tracer::trace(  void Tracer::traceCIMException(
     const Uint32 traceComponent,     const Uint32 traceComponent,
     const Uint32 level,      const Uint32 traceLevel,
     const String& string)      const CIMException& cimException)
 { {
     trace("unknown", 0, traceComponent, level, string);      PEGASUS_ASSERT(traceLevel != LEVEL1);
       if (_isTraceEnabled(traceComponent, traceLevel))
       {
           _traceCIMException(traceComponent, cimException);
       }
 } }
  
 #endif /* !PEGASUS_REMOVE_TRACE */ #endif /* !PEGASUS_REMOVE_TRACE */

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