(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.35 and 1.42

version 1.35, 2008/05/15 17:24:34 version 1.42, 2008/09/18 08:01:37
Line 39 
Line 39 
 #include <Pegasus/Common/System.h> #include <Pegasus/Common/System.h>
 #include <Pegasus/Common/Logger.h> #include <Pegasus/Common/Logger.h>
 #include <Pegasus/Common/InternalException.h> #include <Pegasus/Common/InternalException.h>
 #include <Pegasus/Common/TraceComponents.h>  
 #include <Pegasus/Common/TraceHandler.h> #include <Pegasus/Common/TraceHandler.h>
 #include <Pegasus/Common/Linkage.h> #include <Pegasus/Common/Linkage.h>
 #include <Pegasus/Common/SharedPtr.h> #include <Pegasus/Common/SharedPtr.h>
  
 PEGASUS_NAMESPACE_BEGIN PEGASUS_NAMESPACE_BEGIN
  
   /**
       Trace component identifiers.  This list must be kept in sync with the
       TRACE_COMPONENT_LIST in Tracer.cpp.
   */
   enum TraceComponentId
   {
       TRC_XML_PARSER,
       TRC_XML_WRITER,
       TRC_XML_READER,
       TRC_XML_IO,
       TRC_HTTP,
       TRC_CIM_DATA,
       TRC_REPOSITORY,
       TRC_DISPATCHER,
       TRC_OS_ABSTRACTION,
       TRC_CONFIG,
       TRC_IND_HANDLER,
       TRC_AUTHENTICATION,
       TRC_AUTHORIZATION,
       TRC_USER_MANAGER,
       TRC_REGISTRATION,
       TRC_SHUTDOWN,
       TRC_SERVER,
       TRC_INDICATION_SERVICE,
       TRC_INDICATION_SERVICE_INTERNAL,
       TRC_MESSAGEQUEUESERVICE,
       TRC_PROVIDERMANAGER,
       TRC_OBJECTRESOLUTION,
       TRC_WQL,
       TRC_CQL,
       TRC_THREAD,
       TRC_IPC,
       TRC_IND_HANDLE,
       TRC_EXP_REQUEST_DISP,
       TRC_SSL,
       TRC_CONTROLPROVIDER,
       TRC_CIMOM_HANDLE,
       TRC_BINARY_MSG_HANDLER,
       TRC_L10N,
       TRC_EXPORT_CLIENT,
       TRC_LISTENER,
       TRC_DISCARDED_DATA,
       TRC_PROVIDERAGENT,
       TRC_IND_FORMATTER,
       TRC_STATISTICAL_DATA,
       TRC_CMPIPROVIDER,
       TRC_INDICATION_GENERATION,
       TRC_INDICATION_RECEIPT,
       TRC_CMPIPROVIDERINTERFACE,
       TRC_WSMSERVER,
       TRC_LOGMSG
   };
   
 /** Token used for tracing functions. /** Token used for tracing functions.
 */ */
 struct TracerToken struct TracerToken
 { {
     Uint32 component;      TraceComponentId component;
     const char* method;     const char* method;
 }; };
  
Line 60 
Line 112 
 { {
 public: public:
  
   
     /** Trace facilities     /** Trace facilities
         File - tracing occurs to the trace file         File - tracing occurs to the trace file
         Log  - tracing occurs through the Pegasus Logger class         Log  - tracing occurs through the Pegasus Logger class
Line 72 
Line 123 
     enum TRACE_FACILITY_INDEX     enum TRACE_FACILITY_INDEX
     {     {
         TRACE_FACILITY_FILE = 0,         TRACE_FACILITY_FILE = 0,
         TRACE_FACILITY_LOG  = 1          TRACE_FACILITY_LOG  = 1,
           TRACE_FACILITY_MEMORY = 2
     };     };
  
  
Line 100 
Line 152 
     static void traceCString(     static void traceCString(
         const char* fileName,         const char* fileName,
         const Uint32 lineNum,         const Uint32 lineNum,
         const Uint32 traceComponent,          const TraceComponentId traceComponent,
         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 111 
Line 163 
         @param cimException    the CIMException to be traced.         @param cimException    the CIMException to be traced.
      */      */
     static void traceCIMException(     static void traceCIMException(
         const Uint32 traceComponent,          const TraceComponentId traceComponent,
         const Uint32 level,         const Uint32 level,
         const CIMException& cimException);         const CIMException& cimException);
  
Line 162 
Line 214 
     */     */
     static Uint32 setTraceFacility(const String& traceFacility);     static Uint32 setTraceFacility(const String& traceFacility);
  
       /** Get trace facility currently in use
           @return TRACE_FACILITY_FILE - if trace facility is file
                   TRACE_FACILITY_LOG - if trace facility is the log
                   TRACE_FACILITY_MEMORY - if trace facility is memory tracing
       */
       static Uint32 getTraceFacility();
   
       /** Set buffer size to be used for the memory tracing facility
           @param bufferSize buffer size in Kbyte to be used for memory tracing
           @return true   if function was successfully.
       */
       static Boolean setTraceMemoryBufferSize(Uint32 bufferSize);
   
       /** Flushes the trace buffer to traceFilePath. This method will only
           have an effect when traceFacility=Memory.
       */
       static void flushTrace();
   
     /** Traces method entry.     /** Traces method entry.
         @param token           TracerToken         @param token           TracerToken
         @param fileName        filename of the trace originator         @param fileName        filename of the trace originator
Line 173 
Line 243 
         TracerToken& token,         TracerToken& token,
         const char* file,         const char* file,
         size_t line,         size_t line,
         Uint32 component,          TraceComponentId traceComponent,
         const char* method);         const char* method);
  
     /** Traces method exit.     /** Traces method exit.
Line 217 
Line 287 
      */      */
     static Boolean isValidTraceFacility( const String& traceFacility );     static Boolean isValidTraceFacility( const String& traceFacility );
  
     /** Specify the name of the module being traced.  If non-empty, this      /** Signals the trace to be running OOP and provides the file name
           extension of  the trace file.  If non-empty, this
         value is used as an extension to the name of the trace file.         value is used as an extension to the name of the trace file.
         @param  moduleName Name of the module being traced.          @param  oopTraceFileExtension Trace file extension.
      */      */
     static void setModuleName(const String& moduleName);      static void setOOPTraceFileExtension(const String& oopTraceFileExtension);
  
     /**     /**
     */     */
Line 233 
Line 304 
     // @return   0               if the component and level are not enabled     // @return   0               if the component and level are not enabled
     //           1               if the component and level are enabled     //           1               if the component and level are enabled
     static Boolean isTraceEnabled(     static Boolean isTraceEnabled(
         const Uint32 traceComponent,          const TraceComponentId traceComponent,
         const Uint32 level);         const Uint32 level);
  
 private: private:
Line 260 
Line 331 
     static const Uint32 _STRLEN_MAX_UNSIGNED_INT;     static const Uint32 _STRLEN_MAX_UNSIGNED_INT;
     static const Uint32 _STRLEN_MAX_PID_TID;     static const Uint32 _STRLEN_MAX_PID_TID;
     AutoArrayPtr<Boolean> _traceComponentMask;     AutoArrayPtr<Boolean> _traceComponentMask;
       Uint32                _traceMemoryBufferSize;
     Uint32                _traceFacility;     Uint32                _traceFacility;
     //Is true if any components are set at the component mask     //Is true if any components are set at the component mask
     Boolean               _componentsAreSet;     Boolean               _componentsAreSet;
       Boolean               _runningOOP;
     Uint32                _traceLevelMask;     Uint32                _traceLevelMask;
     AutoPtr<TraceHandler> _traceHandler;      TraceHandler*         _traceHandler;
     String              _moduleName;      String                _traceFile;
       String                _oopTraceFileExtension;
     static Tracer*      _tracerInstance;     static Tracer*      _tracerInstance;
  
     // Message Strings for function Entry and Exit     // Message Strings for function Entry and Exit
Line 275 
Line 349 
     // Factory function to create an instance of the matching trace handler     // Factory function to create an instance of the matching trace handler
     // for the given type of traceFacility.     // for the given type of traceFacility.
     // @param    traceFacility  type of trace handler to create     // @param    traceFacility  type of trace handler to create
     // @return   an instance of a trace handler class. For invalid trace      void _setTraceHandler( Uint32 traceFacility );
     //           facilities always creates a traceFileHandler.  
     TraceHandler* getTraceHandler( Uint32 traceFacility );      // Validates if the given file path if it is eligible for writing traces.
       // @param    fileName      a file intended to be used to write traces
       static Boolean _isValidTraceFile(String fileName);
  
     // 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.
Line 288 
Line 364 
     static void _trace(     static void _trace(
         const char* fileName,         const char* fileName,
         const Uint32 lineNum,         const Uint32 lineNum,
         const Uint32 traceComponent,          const TraceComponentId traceComponent,
         const char* fmt,         const char* fmt,
         va_list argList);         va_list argList);
  
Line 299 
Line 375 
     //  @param    CIMException    the CIMException to be traced.     //  @param    CIMException    the CIMException to be traced.
     //     //
     static void _traceCIMException(     static void _traceCIMException(
         const Uint32 traceComponent,          const TraceComponentId traceComponent,
         const CIMException& cimException);         const CIMException& cimException);
  
     // Called by all the trace interfaces to log message     // Called by all the trace interfaces to log message
Line 307 
Line 383 
     // @param    traceComponent  component being traced     // @param    traceComponent  component being traced
     // @param    cstring         the string to be traced     // @param    cstring         the string to be traced
     static void _traceCString(     static void _traceCString(
         const Uint32 traceComponent,          const TraceComponentId traceComponent,
         const char* message,         const char* message,
         const char* cstring);         const char* cstring);
  
Line 317 
Line 393 
     // @param    *fmt            printf style format string     // @param    *fmt            printf style format string
     // @param    argList         variable argument list     // @param    argList         variable argument list
     static void _trace(     static void _trace(
         const Uint32 traceComponent,          const TraceComponentId traceComponent,
         const char* message,         const char* message,
         const char* fmt,         const char* fmt,
         va_list argList);         va_list argList);
Line 330 
Line 406 
     static void _traceMethod(     static void _traceMethod(
         const char* fileName,         const char* fileName,
         const Uint32 lineNum,         const Uint32 lineNum,
         const Uint32 traceComponent,          const TraceComponentId traceComponent,
         const char* methodEntryExit,         const char* methodEntryExit,
         const char* method);         const char* method);
  
Line 348 
Line 424 
  
     friend class TraceCallFrame;     friend class TraceCallFrame;
     friend class TracePropertyOwner;     friend class TracePropertyOwner;
       friend class TraceMemoryHandler;
       friend class TraceFileHandler;
 }; };
  
 //============================================================================== //==============================================================================
Line 362 
Line 440 
 inline void Tracer::traceCString( inline void Tracer::traceCString(
     const char* fileName,     const char* fileName,
     const Uint32 lineNum,     const Uint32 lineNum,
     const Uint32 traceComponent,      const TraceComponentId traceComponent,
     const char* cstring)     const char* cstring)
 { {
     // empty function     // empty function
 } }
  
 inline void Tracer::traceCIMException( inline void Tracer::traceCIMException(
     const Uint32 traceComponent,      const TraceComponentId traceComponent,
     const Uint32 level,     const Uint32 level,
     const CIMException& cimException)     const CIMException& cimException)
 { {
Line 400 
Line 478 
     // empty function     // empty function
 } }
  
 inline Uint32 Tracer::setTraceFacility(const String& traceComponents)  inline Uint32 Tracer::setTraceFacility(const String& traceFacility)
 { {
     // empty function     // empty function
       return 0;
   }
   
   inline Uint32 Tracer::getTraceFacility()
   {
       // empty function
       return 0;
   }
   
   inline Boolean Tracer::setTraceMemoryBufferSize(Uint32 bufferSize)
   {
       // empty function
       return true;
   }
   
   inline void Tracer::flushTrace()
   {
       // empty function
       return;
 } }
  
 #endif /* PEGASUS_REMOVE_TRACE */ #endif /* PEGASUS_REMOVE_TRACE */
Line 427 
Line 524 
  
 # define PEG_METHOD_ENTER(comp,meth) # define PEG_METHOD_ENTER(comp,meth)
 # define PEG_METHOD_EXIT() # define PEG_METHOD_EXIT()
 # define PEG_TRACE_STRING(comp,level,string)  
 # define PEG_TRACE(VAR_ARGS) # define PEG_TRACE(VAR_ARGS)
 # define PEG_TRACE_CSTRING(comp,level,chars) # define PEG_TRACE_CSTRING(comp,level,chars)
  
 #else /* PEGASUS_REMOVE_TRACE */ #else /* PEGASUS_REMOVE_TRACE */
  
   // remover trace code for method enter/exit
   # ifdef  PEGASUS_REMOVE_METHODTRACE
   #  define PEG_METHOD_ENTER(comp,meth)
   #  define PEG_METHOD_EXIT()
   # else
 # define PEG_METHOD_ENTER(comp, meth) \ # define PEG_METHOD_ENTER(comp, meth) \
     TracerToken __tracerToken; \     TracerToken __tracerToken; \
     __tracerToken.method = 0; \     __tracerToken.method = 0; \
Line 451 
Line 552 
             Tracer::traceExit(__tracerToken PEGASUS_COMMA_FILE_LINE); \             Tracer::traceExit(__tracerToken PEGASUS_COMMA_FILE_LINE); \
     } \     } \
     while (0)     while (0)
   # endif
 // Macro for Trace String.  the do construct allows this to appear  
 // as a single statement.  
 # define PEG_TRACE_STRING(comp, level, string) \  
     do \  
     { \  
         if (Tracer::isTraceOn()) \  
         { \  
             if (Tracer::isTraceEnabled(comp, level)) \  
             { \  
                 Tracer::traceCString(PEGASUS_FILE_LINE_COMMA \  
                                      comp, \  
                                      (const char*) (string).getCString()); \  
             } \  
         } \  
     } \  
     while (0)  
  
 // Macro to trace character lists.  the do construct allows this to appear // Macro to trace character lists.  the do construct allows this to appear
 // as a single statement. // as a single statement.
Line 505 
Line 590 
  
     PEGASUS_FORMAT(4, 5)     PEGASUS_FORMAT(4, 5)
     inline void invoke(     inline void invoke(
         const Uint32 component,          const TraceComponentId component,
         const Uint32 level,         const Uint32 level,
         const char* format,         const char* format,
         ...)         ...)

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