(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.4 and 1.23

version 1.4, 2002/01/17 05:33:49 version 1.23, 2005/11/30 21:04:52
Line 1 
Line 1 
 //%/////////////////////////////////////////////////////////////////////////////  //%2005////////////////////////////////////////////////////////////////////////
 // //
 // Copyright (c) 2000, 2001 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.
 // //
 // 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 23 
Line 29 
 // //
 // Author: Sushma Fernandes, Hewlett-Packard Company (sushma_fernandes@hp.com) // Author: Sushma Fernandes, Hewlett-Packard Company (sushma_fernandes@hp.com)
 // //
 // Modified By:  // Modified By: Jenny Yu, Hewlett-Packard Company (jenny_yu@hp.com)
   //              Amit K Arora, IBM (amita@in.ibm.com) for PEP#101
   //              Roger Kumpf, Hewlett-Packard Company (roger_kumpf@hp.com)
   //              David Dillard, Symantec Corp. (david_dillard@symantec.com)
 // //
 //%///////////////////////////////////////////////////////////////////////////// //%/////////////////////////////////////////////////////////////////////////////
  
Line 31 
Line 40 
 #define Pegasus_Tracer_h #define Pegasus_Tracer_h
  
 #include <stdarg.h> #include <stdarg.h>
 #include <fstream>  
 #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>
   #include <Pegasus/Common/InternalException.h>
 #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>
 // REVIEW: Ask how this all works (note to myself)?  #include <Pegasus/Common/AutoPtr.h>
  
 PEGASUS_NAMESPACE_BEGIN PEGASUS_NAMESPACE_BEGIN
  
Line 106 
Line 115 
             // empty function             // empty function
         }         }
  
           inline static void trace(
               const char*   fileName,
               const Uint32  lineNum,
               const Uint32  traceComponent,
               const Uint32  traceLevel,
               const String& traceString)
           {
               // empty function
           }
   
           inline static void traceCIMException(
               const Uint32  traceComponent,
               const Uint32  traceLevel,
               CIMException  cimException)
           {
               // empty function
           }
   
         static Uint32 setTraceFile(const char* traceFile)         static Uint32 setTraceFile(const char* traceFile)
         {         {
             // empty function             // empty function
Line 119 
Line 146 
         }         }
  
         static void setTraceComponents(         static void setTraceComponents(
           const String traceComponents)            const String& traceComponents)
         {         {
               // empty function               // empty function
         }         }
Line 138 
Line 165 
             const char*  data,             const char*  data,
             const Uint32 size)             const Uint32 size)
         {         {
               if (_traceOn)
               {
             _traceBuffer( traceComponent, traceLevel, data, size );             _traceBuffer( traceComponent, traceLevel, data, size );
         }         }
           }
  
         /** Traces the specified number of bytes in a given buffer         /** Traces the specified number of bytes in a given buffer
             Overloaded to include the filename and the line number             Overloaded to include the filename and the line number
Line 159 
Line 189 
             const char*  data,             const char*  data,
             const Uint32 size)             const Uint32 size)
         {         {
               if (_traceOn)
               {
             _traceBuffer( fileName, lineNum,             _traceBuffer( fileName, lineNum,
                           traceComponent, traceLevel, data, size );                           traceComponent, traceLevel, data, size );
         }         }
           }
  
  
         /** Traces the given message         /** Traces the given message
Line 176 
Line 209 
             const char *fmt,             const char *fmt,
             ...)             ...)
         {         {
               if (_traceOn)
               {
             va_list argList;             va_list argList;
  
             va_start(argList,fmt);             va_start(argList,fmt);
             _trace(traceComponent,traceLevel,fmt,argList);             _trace(traceComponent,traceLevel,fmt,argList);
             va_end(argList);             va_end(argList);
         }         }
           }
  
         /** Traces the given message. Overloaded to include the filename and         /** Traces the given message. Overloaded to include the filename and
             the line number of trace origin.             the line number of trace origin.
Line 200 
Line 236 
             const char* fmt,             const char* fmt,
             ...)             ...)
         {         {
               if (_traceOn)
               {
             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,traceLevel,fmt,argList);
             va_end(argList);             va_end(argList);
         }         }
           }
   
           /** 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    traceLevel      trace level of the trace message
               @param    traceString     the string to be traced
            */
           inline static void trace(
               const char*   fileName,
               const Uint32  lineNum,
               const Uint32  traceComponent,
               const Uint32  traceLevel,
               const String& traceString)
           {
               if (_traceOn)
               {
                   _traceString( fileName, lineNum, traceComponent, traceLevel,
                                 traceString );
               }
           }
   
           /** Traces the message in the given CIMException object.  The message
               written to the trace file will include the source filename and
               line number of the CIMException originator.
               @param    traceComponent  component being traced
               @param    traceLevel      trace level of the trace message
               @param    CIMException    the CIMException to be traced.
            */
           inline static void traceCIMException(
               const Uint32  traceComponent,
               const Uint32  traceLevel,
               CIMException  cimException)
           {
               if (_traceOn)
               {
                   _traceCIMException( traceComponent, traceLevel, cimException );
               }
           }
  
         /** 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
                       1               if an error occurs while opening the file                        1               if the traceFile is an empty string or
                                         if an error occurs while opening the file
                                       in append mode                                       in append mode
         */         */
         static Uint32 setTraceFile(const char* traceFile);         static Uint32 setTraceFile(const char* traceFile);
Line 227 
Line 307 
                       components should be separated by ','                       components should be separated by ','
         */         */
         static void setTraceComponents(         static void setTraceComponents(
            const String traceComponents);             const String& traceComponents);
  
     #endif     #endif
  
Line 245 
Line 325 
         const Uint32 traceComponent,         const Uint32 traceComponent,
         const char* methodName)         const char* methodName)
     {     {
           if (_traceOn)
           {
         _traceEnter( fileName, lineNum, traceComponent, "%s %s",         _traceEnter( fileName, lineNum, traceComponent, "%s %s",
             _FUNC_ENTER_MSG, methodName);                           _METHOD_ENTER_MSG, methodName);
           }
     }     }
  
     /** Traces method exit.     /** Traces method exit.
Line 261 
Line 344 
         const Uint32 traceComponent,         const Uint32 traceComponent,
         const char* methodName)         const char* methodName)
     {     {
           if (_traceOn)
           {
         _traceExit( fileName, lineNum, traceComponent, "%s %s",         _traceExit( fileName, lineNum, traceComponent, "%s %s",
             _FUNC_EXIT_MSG, methodName);                          _METHOD_EXIT_MSG, methodName);
           }
     }     }
  
     /** Validates the File Path for the trace File     /** Validates the File Path for the trace File
Line 270 
Line 356 
         @return   1        if the file path is valid         @return   1        if the file path is valid
                   0        if the file path is invalid                   0        if the file path is invalid
      */      */
     static Boolean isValid(const char* filePath);      static Boolean isValidFileName(const char* filePath);
   
       /** Validates the trace components
           @param    traceComponents   comma separated list of trace components
           @return   1        if the components are valid
                     0        if one or more components are invalid
        */
       static Boolean isValidComponents(const String& traceComponents);
  
     /** Validates the trace components     /** Validates the trace components
         @param    traceComponents   comma separated list of trace components         @param    traceComponents   comma separated list of trace components
Line 278 
Line 371 
         @return   1        if the components are valid         @return   1        if the components are valid
                   0        if one or more components are invalid                   0        if one or more components are invalid
      */      */
     static Boolean isValid(      static Boolean isValidComponents(
        const String traceComponents, String& invalidComponents=_EMPTY_STRING);          const String& traceComponents,
           String& invalidComponents);
   
       /** Specify the name of the module being traced.  If non-empty, this
           value is used as an extension to the name of the trace file.
           @param    moduleName   Name of the module being traced.
        */
       static void setModuleName(const String& moduleName);
   
       static Boolean isTraceOn() { return _traceOn; }
  
 private: private:
  
       /** A static single indicator if tracing is turned on allowing to
           determine the state of trace quickly without many instructions.
           Used to wrap the public static trace interface methods to avoid
           obsolete calls when tracing is turned off.
        */
       static Boolean _traceOn;
   
     static const char   _COMPONENT_SEPARATOR;     static const char   _COMPONENT_SEPARATOR;
     static const Uint32 _NUM_COMPONENTS;     static const Uint32 _NUM_COMPONENTS;
     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;
     static const Boolean _SUCCESS;     static const Boolean _SUCCESS;
     static const Boolean _FAILURE;     static const Boolean _FAILURE;
     static String  _EMPTY_STRING;      AutoArrayPtr<Boolean> _traceComponentMask;
     Boolean*            _traceComponentMask;  
     Uint32              _traceLevelMask;     Uint32              _traceLevelMask;
     TraceFileHandler*   _traceHandler;      AutoPtr<TraceFileHandler> _traceHandler;
       String              _moduleName;
     static Tracer*      _tracerInstance;     static Tracer*      _tracerInstance;
  
     // Message Strings for fucntion Entry and Exit      // Message Strings for function Entry and Exit
     static const char _FUNC_ENTER_MSG[];      static const char _METHOD_ENTER_MSG[];
     static const char _FUNC_EXIT_MSG[];      static const char _METHOD_EXIT_MSG[];
  
     // Message Strings for Logger     // Message Strings for Logger
     static const char _LOG_MSG1[];      static const char _LOG_MSG[];
     static const char _LOG_MSG2[];  
     static const char _LOG_MSG3[];  
  
     // Checks if trace is enabled for the given component and trace level     // Checks if trace is enabled for the given component and trace level
     // @param    traceComponent  component being traced     // @param    traceComponent  component being traced
Line 367 
Line 474 
         const char*  data,         const char*  data,
         const Uint32 size);         const Uint32 size);
  
       //  Traces the given string.
       //  @param    traceComponent  component being traced
       //  @param    traceLevel      trace level of the trace message
       //  @param    traceString     the string to be traced
       //
       static void _traceString(
           const Uint32  traceComponent,
           const Uint32  traceLevel,
           const String& traceString);
   
       //  Traces a 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    traceLevel      trace level of the trace message
       //  @param    traceString     the string to be traced
       //
       static void _traceString(
           const char*   fileName,
           const Uint32  lineNum,
           const Uint32  traceComponent,
           const Uint32  traceLevel,
           const String& traceString);
   
       //  Traces the message in the given CIMException object.  The message
       //  to be written to the trace file will include the source filename and
       //  line number of the CIMException originator.
       //  @param    traceComponent  component being traced
       //  @param    traceLevel      trace level of the trace message
       //  @param    CIMException    the CIMException to be traced.
       //
       static void _traceCIMException(
           const Uint32  traceComponent,
           const Uint32  traceLevel,
           CIMException  cimException);
   
     // Called by all the trace interfaces to log message to the     // Called by all the trace interfaces to log message to the
     // trace file     // trace file
     // @param    fileName        filename of the trace originator     // @param    fileName        filename of the trace originator
Line 418 
Line 562 
     static Tracer* _getInstance();     static Tracer* _getInstance();
 }; };
  
 // Define the macros for method entry/exit  // Define the macros for method entry/exit, and tracing a given string
 #ifdef PEGASUS_REMOVE_TRACE #ifdef PEGASUS_REMOVE_TRACE
     #define PEG_FUNC_ENTER(traceComponent,methodName)  #   define PEG_METHOD_ENTER(traceComponent,methodName)
     #define PEG_FUNC_EXIT(traceComponent,methodName)  #   define PEG_METHOD_EXIT()
   #   define PEG_TRACE_STRING(traceComponent,traceLevel,traceString)
   #   define PEG_TRACE(VAR_ARGS)
 #else #else
     /** Macro for tracing method entry     /** Macro for tracing method entry
         @param    traceComponent  component being traced         @param    traceComponent  component being traced
         @param    methodName      name of the method         @param    methodName      name of the method
      */      */
     #define PEG_FUNC_ENTER(traceComponent,methodName) \  #   define PEG_METHOD_ENTER(traceComponent,methodName) \
         Tracer::traceEnter(__FILE__, __LINE__,traceComponent,methodName)          static const char *PEG_METHOD_NAME = methodName; \
           static const Uint32 PEG_TRACE_COMPONENT = traceComponent; \
           if (Tracer::isTraceOn()) \
           { \
               Tracer::traceEnter( \
                   __FILE__,__LINE__,PEG_TRACE_COMPONENT,PEG_METHOD_NAME); \
           } \
  
     /** Macro for tracing method exit     /** Macro for tracing method exit
        */
   #   define PEG_METHOD_EXIT() \
           do \
           { \
               if (Tracer::isTraceOn()) \
                   Tracer::traceExit( \
                       __FILE__,__LINE__,PEG_TRACE_COMPONENT,PEG_METHOD_NAME); \
           } \
           while (0)
   
       /** Macro for tracing a string
         @param    traceComponent  component being traced         @param    traceComponent  component being traced
         @param    methodName      name of the method          @param    traceLevel      trace level of the trace message
           @param    traceString     the string to be traced
      */      */
     #define PEG_FUNC_EXIT(traceComponent,methodName) \  #   define PEG_TRACE_STRING(traceComponent,traceLevel,traceString) \
         Tracer::traceExit(__FILE__,__LINE__,traceComponent,methodName)          do \
           { \
               if (Tracer::isTraceOn()) \
                   Tracer::trace( \
                       __FILE__, __LINE__,traceComponent,traceLevel,traceString); \
           } \
           while (0)
   
   #   define PEG_TRACE(VAR_ARGS) \
           do \
           { \
               if (Tracer::isTraceOn()) \
                   Tracer::trace VAR_ARGS; \
           } \
           while (0)
   
 #endif #endif
  
 PEGASUS_NAMESPACE_END PEGASUS_NAMESPACE_END

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