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

Diff for /pegasus/src/Pegasus/Common/Tracer.h between version 1.27.4.2 and 1.33

version 1.27.4.2, 2007/05/25 17:39:01 version 1.33, 2008/02/27 20:28:16
Line 34 
Line 34 
 #ifndef Pegasus_Tracer_h #ifndef Pegasus_Tracer_h
 #define Pegasus_Tracer_h #define Pegasus_Tracer_h
  
 #include <stdarg.h>  #include <cstdarg>
 #include <Pegasus/Common/String.h> #include <Pegasus/Common/String.h>
 #include <Pegasus/Common/System.h> #include <Pegasus/Common/System.h>
 #include <Pegasus/Common/Logger.h> #include <Pegasus/Common/Logger.h>
Line 42 
Line 42 
 #include <Pegasus/Common/TraceComponents.h> #include <Pegasus/Common/TraceComponents.h>
 #include <Pegasus/Common/TraceFileHandler.h> #include <Pegasus/Common/TraceFileHandler.h>
 #include <Pegasus/Common/Linkage.h> #include <Pegasus/Common/Linkage.h>
 #include <Pegasus/Common/AutoPtr.h>  #include <Pegasus/Common/SharedPtr.h>
  
 PEGASUS_NAMESPACE_BEGIN PEGASUS_NAMESPACE_BEGIN
  
Line 73 
Line 73 
     static const Uint32 LEVEL3;     static const Uint32 LEVEL3;
     static const Uint32 LEVEL4;     static const Uint32 LEVEL4;
  
     /** Traces the given message  
         @param traceComponent  component being traced  
         @param level           trace level of the trace message  
         @param *fmt            printf style format string  
         @param ...             variable argument list  
      */  
     static void trace(  
         const Uint32 traceComponent,  
         const Uint32 level,  
         const char *fmt,  
         ...);  
   
     /** Traces the given message. Overloaded to include the filename and  
         the line number of trace origin.  
         @param fileName        filename of the trace originator  
         @param lineNum         line number of the trace originator  
         @param traceComponent  component being traced  
         @param level           trace level of the trace message  
         @param *fmt            printf style format string  
         @param ...             variable argument list  
      */  
     static void trace(  
         const char* fileName,  
         const Uint32 lineNum,  
         const Uint32 traceComponent,  
         const Uint32 level,  
         const char* fmt,  
         ...);  
   
     /** Traces the given string.  Overloaded to include the filename  
         and line number of trace origin.  
         @param fileName        filename of the trace originator  
         @param lineNum         line number of the trace originator  
         @param traceComponent  component being traced  
         @param level           trace level of the trace message  
         @param string          the string to be traced  
      */  
     static void traceString(  
         const char* fileName,  
         const Uint32 lineNum,  
         const Uint32 traceComponent,  
         const Uint32 level,  
         const String& string);  
   
     /** Traces the given character string.     /** Traces the given character string.
         Overloaded to include the filename         Overloaded to include the filename
         and line number of trace origin.         and line number of trace origin.
         @param fileName        filename of the trace originator         @param fileName        filename of the trace originator
         @param lineNum         line number of the trace originator         @param lineNum         line number of the trace originator
         @param traceComponent  component being traced         @param traceComponent  component being traced
         @param level           trace level of the trace message  
         @param cstring         the character string to be traced         @param cstring         the character string to be traced
      */      */
     static void traceCString(     static void traceCString(
         const char* fileName,         const char* fileName,
         const Uint32 lineNum,         const Uint32 lineNum,
         const Uint32 traceComponent,         const Uint32 traceComponent,
         const Uint32 level,  
         const char* cstring);         const char* cstring);
  
     /** Traces the message in the given CIMException object.  The message     /** Traces the message in the given CIMException object.  The message
Line 138 
Line 92 
         line number of the CIMException originator.         line number of the CIMException originator.
         @param traceComponent  component being traced         @param traceComponent  component being traced
         @param level           trace level of the trace message         @param level           trace level of the trace message
         @param CIMException    the CIMException to be traced.          @param cimException    the CIMException to be traced.
      */      */
     static void traceCIMException(     static void traceCIMException(
         const Uint32 traceComponent,         const Uint32 traceComponent,
Line 153 
Line 107 
         If true, the username/passwd is suppressed and returned.         If true, the username/passwd is suppressed and returned.
         Otherwise the request message is returned without any changes.         Otherwise the request message is returned without any changes.
  
         The caller is responsible for deleting the returned character array.  
   
         @param requestMessage  requestMessage to be checked         @param requestMessage  requestMessage to be checked
  
         @return request message         @return request message
   
     */     */
     static char* getHTTPRequestMessage(      static SharedArrayPtr<char> getHTTPRequestMessage(
         const Buffer& requestMessage);         const Buffer& requestMessage);
  
     /** Set the trace file to the given file     /** Set the trace file to the given file
Line 243 
Line 196 
     */     */
     static Boolean isTraceOn() { return _traceOn; }     static Boolean isTraceOn() { return _traceOn; }
  
       // Checks if trace is enabled for the given component and trace level
       // @param    traceComponent  component being traced
       // @param    level      level of the trace message
       // @return   0               if the component and level are not enabled
       //           1               if the component and level are enabled
       static Boolean isTraceEnabled(
           const Uint32 traceComponent,
           const Uint32 level);
   
 private: private:
  
     /** A static single indicator if tracing is turned on allowing to     /** A static single indicator if tracing is turned on allowing to
Line 271 
Line 233 
     // Message Strings for Logger     // Message Strings for Logger
     static const char _LOG_MSG[];     static const char _LOG_MSG[];
  
     // Checks if trace is enabled for the given component and trace level  
     // @param    traceComponent  component being traced  
     // @param    level      level of the trace message  
     // @return   0               if the component and level are not enabled  
     //           1               if the component and level are enabled  
     static Boolean _isTraceEnabled(  
         const Uint32 traceComponent,  
         const Uint32 level);  
   
     // Traces the given message  
     //  @param    traceComponent  component being traced  
     //  @param    *fmt            printf style format string  
     //  @param    argList         variable argument list  
     static void _trace(  
         const Uint32 traceComponent,  
         const char* fmt,  
         va_list argList);  
   
     // Traces the given message. Overloaded to include the file name and the     // Traces the given message. Overloaded to include the file name and the
     // line number as one of the parameters.     // line number as one of the parameters.
     // @param    traceComponent  component being traced     // @param    traceComponent  component being traced
Line 302 
Line 246 
         const char* fmt,         const char* fmt,
         va_list argList);         va_list argList);
  
     //  Traces a given character string.  Overloaded to include the filename  
     //  and line number of trace origin.  
     //  @param    fileName        filename of the trace originator  
     //  @param    lineNum         line number of the trace originator  
     //  @param    traceComponent  component being traced  
     //  @param    cstring         the character string to be traced  
     //  
     static void _traceCString(  
         const char* fileName,  
         const Uint32 lineNum,  
         const Uint32 traceComponent,  
         const char* cstring);  
   
     //  Traces the message in the given CIMException object.  The message     //  Traces the message in the given CIMException object.  The message
     //  to be written to the trace file will include the source filename and     //  to be written to the trace file will include the source filename and
     //  line number of the CIMException originator.     //  line number of the CIMException originator.
Line 368 
Line 299 
     // Returns the Singleton instance of the Tracer     // Returns the Singleton instance of the Tracer
     // @return   Tracer*  Instance of Tracer     // @return   Tracer*  Instance of Tracer
     static Tracer* _getInstance();     static Tracer* _getInstance();
   
       friend class TraceCallFrame;
 }; };
  
 //============================================================================== //==============================================================================
Line 379 
Line 312 
  
 #ifdef PEGASUS_REMOVE_TRACE #ifdef PEGASUS_REMOVE_TRACE
  
 inline void Tracer::trace(  inline void Tracer::traceCString(
     const Uint32 traceComponent,  
     const Uint32 level,  
     const char *fmt,  
     ...)  
 {  
     // empty function  
 }  
   
 inline void Tracer::trace(  
     const char* fileName,  
     const Uint32 lineNum,  
     const Uint32 traceComponent,  
     const Uint32 level,  
     const char* fmt,  
     ...)  
 {  
     // empty function  
 }  
   
 inline void Tracer::traceString(  
     const char* fileName,     const char* fileName,
     const Uint32 lineNum,     const Uint32 lineNum,
     const Uint32 traceComponent,     const Uint32 traceComponent,
     const Uint32 level,      const char* cstring)
     const String& string)  
 { {
     // empty function     // empty function
 } }
  
 inline void Tracer::traceCString(  inline void Tracer::traceCIMException(
     const char* fileName,  
     const Uint32 lineNum,  
     const Uint32 traceComponent,     const Uint32 traceComponent,
     const Uint32 level,     const Uint32 level,
     const char* cstring)      const CIMException& cimException)
 { {
     // empty function     // empty function
 } }
  
 static char* getHTTPRequestMessage(  static SharedArrayPtr<char> getHTTPRequestMessage(
     const Buffer& requestMessage)     const Buffer& requestMessage)
 { {
     //empty function     //empty function
     return 0;      return SharedArrayPtr<char>();
 }  
   
 inline void Tracer::traceCIMException(  
     const Uint32 traceComponent,  
     const Uint32 level,  
     const CIMException& cimException)  
 {  
     // empty function  
 } }
  
 inline Uint32 Tracer::setTraceFile(const char* traceFile) inline Uint32 Tracer::setTraceFile(const char* traceFile)
Line 481 
Line 383 
  
 # define PEG_METHOD_ENTER(comp, meth) \ # define PEG_METHOD_ENTER(comp, meth) \
     TracerToken __tracerToken; \     TracerToken __tracerToken; \
       __tracerToken.method = 0; \
     do \     do \
     { \     { \
         if (Tracer::isTraceOn()) \         if (Tracer::isTraceOn()) \
             Tracer::traceEnter(__tracerToken PEGASUS_COMMA_FILE_LINE, comp, meth); \              Tracer::traceEnter( \
                   __tracerToken PEGASUS_COMMA_FILE_LINE, comp, meth); \
     } \     } \
     while (0)     while (0)
  
Line 502 
Line 406 
     do \     do \
     { \     { \
         if (Tracer::isTraceOn()) \         if (Tracer::isTraceOn()) \
             Tracer::traceString(PEGASUS_FILE_LINE_COMMA comp, level, string); \          { \
               PEGASUS_ASSERT(level != Tracer::LEVEL1); \
               if (Tracer::isTraceEnabled(comp, level)) \
               { \
                   Tracer::traceCString(PEGASUS_FILE_LINE_COMMA \
                                        comp, \
                                        (const char*) (string).getCString()); \
               } \
           } \
     } \     } \
     while (0)     while (0)
  
Line 512 
Line 424 
     do \     do \
     { \     { \
         if (Tracer::isTraceOn()) \         if (Tracer::isTraceOn()) \
             Tracer::traceCString(PEGASUS_FILE_LINE_COMMA comp, level, chars); \          { \
               PEGASUS_ASSERT(level != Tracer::LEVEL1); \
               if (Tracer::isTraceEnabled(comp, level)) \
               { \
                   Tracer::traceCString(PEGASUS_FILE_LINE_COMMA comp, chars); \
               } \
           } \
     } \     } \
     while (0)     while (0)
  
 // Macro for Trace variable number of arguments with format string. The trace  //
 // test is included becase of the possible cost of preparing the variable  // This class is constructed with the same arguments passed to PEG_TRACE().
 // number of arguments on each call.  The d construct allows this to be  // The constructor saves all the fixed arguments and calls va_start() on
 // treated as a single statement.  // the varying arguments (wherein the va_list argument is the ap member of
   // this class). The PEG_TRACE() macro eventually calls invoke() with the
   // file and line macros in order to write the trace entry. For more details,
   // see the comments below on the PEG_TRACE() macro.
   //
   class TraceCallFrame
   {
   public:
   
       const char* file;
       Uint32 line;
   
       TraceCallFrame(const char* file_, Uint32 line_) : file(file_), line(line_)
       {
       }
   
       PEGASUS_FORMAT(4, 5)
       inline void invoke(
           const Uint32 component,
           const Uint32 level,
           const char* format,
           ...)
       {
           if (Tracer::isTraceEnabled(component, level))
           {
               va_list ap;
               va_start(ap, format);
               Tracer::_trace(file, line, component, format, ap);
               va_end(ap);
           }
       }
   
       ~TraceCallFrame()
       {
       }
   };
   //
   // This macro is a wrapper for calling the printf-style form of the
   // Tracer::trace() function. Since macros cannot have a varying number of
   // arguments, PEG_TRACE() must be invoked with double parentheses. For
   // example:
   //
   //     PEG_TRACE((TRC_HTTP, Tracer::LEVEL1, "Oops: %d", 999));
   //
   // This macro offers two advantages over the calling trace() directly.
   //
   //     1. It eliminates the call to trace() if isTraceOn() returns false.
   //        This has proven to reduce the expense of servicing a request
   //        (when tracing is off) by as much as 3%.
   //
   //     2. It implicitly injects the __FILE__ and __LINE__ macros, relieving
   //        the caller of this burden.
   //
 # define PEG_TRACE(VAR_ARGS) \ # define PEG_TRACE(VAR_ARGS) \
     do \     do \
     { \     { \
         if (Tracer::isTraceOn()) \         if (Tracer::isTraceOn()) \
             Tracer::trace VAR_ARGS; \          { \
                   TraceCallFrame frame(__FILE__, __LINE__); \
                   frame.invoke VAR_ARGS; \
           } \
     } \     } \
     while (0)     while (0)
  

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