(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.1 and 1.32

version 1.27.4.1, 2007/04/04 11:04:44 version 1.32, 2007/09/14 18:33:50
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 145 
Line 99 
         const Uint32 level,         const Uint32 level,
         const CIMException& cimException);         const CIMException& cimException);
  
       /** Gets an HTTP request message.
   
           Given an HTTP request message, this method checks if the
           message contains a "Basic" authorization header.
   
           If true, the username/passwd is suppressed and returned.
           Otherwise the request message is returned without any changes.
   
           @param requestMessage  requestMessage to be checked
   
           @return request message
   
       */
       static SharedArrayPtr<char> getHTTPRequestMessage(
           const Buffer& requestMessage);
   
     /** Set the trace file to the given file     /** Set the trace file to the given file
         @param  traceFile  full path of the trace file         @param  traceFile  full path of the trace file
         @return 0          if the filepath is valid         @return 0          if the filepath is valid
Line 226 
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 254 
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 285 
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 351 
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 362 
Line 312 
  
 #ifdef PEGASUS_REMOVE_TRACE #ifdef PEGASUS_REMOVE_TRACE
  
 inline void Tracer::trace(  
     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 Uint32 lineNum,  
     const Uint32 traceComponent,  
     const Uint32 level,  
     const String& string)  
 {  
     // empty function  
 }  
   
 inline void Tracer::traceCString( inline void Tracer::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)
 { {
     // empty function     // empty function
Line 410 
Line 329 
     // empty function     // empty function
 } }
  
   static SharedArrayPtr<char> getHTTPRequestMessage(
           const Buffer& requestMessage)
   {
       //empty function
       return SharedArrayPtr<char>();
   }
   
 inline Uint32 Tracer::setTraceFile(const char* traceFile) inline Uint32 Tracer::setTraceFile(const char* traceFile)
 { {
     // empty function     // empty function
Line 457 
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 478 
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 488 
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.1  
changed lines
  Added in v.1.32
No CVS admin address has been configured
 Powered by
ViewCVS 0.9.2