version 1.35, 2008/05/15 17:24:34
|
version 1.44, 2008/10/24 06:03:19
|
|
|
#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. |
|
The tracer uses the _traceComponentMask 64bit field to mask |
|
the user configured components. |
|
|
|
Please ensure that no more than 64 Trace Component ID's are specified. |
|
*/ |
|
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_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; |
}; | }; |
| |
|
|
{ | { |
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 |
|
|
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 |
}; | }; |
| |
| |
|
|
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 |
|
|
@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); |
| |
|
|
*/ | */ |
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 |
|
|
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. |
|
|
*/ | */ |
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); |
| |
/** | /** |
*/ | */ |
|
|
// @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 traceLevel) |
|
{ |
|
return ((traceLevel & _traceLevelMask) && |
|
(_traceComponentMask & ((Uint64)1 << traceComponent))); |
|
} |
| |
private: | private: |
| |
|
|
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; |
AutoArrayPtr<Boolean> _traceComponentMask; |
static Uint64 _traceComponentMask; |
Uint32 _traceFacility; |
static Uint32 _traceLevelMask; |
//Is true if any components are set at the component mask |
|
Boolean _componentsAreSet; |
|
Uint32 _traceLevelMask; |
|
AutoPtr<TraceHandler> _traceHandler; |
|
String _moduleName; |
|
static Tracer* _tracerInstance; | static Tracer* _tracerInstance; |
|
Uint32 _traceMemoryBufferSize; |
|
Uint32 _traceFacility; |
|
Boolean _runningOOP; |
|
TraceHandler* _traceHandler; |
|
String _traceFile; |
|
String _oopTraceFileExtension; |
|
|
| |
// Message Strings for function Entry and Exit | // Message Strings for function Entry and Exit |
static const char _METHOD_ENTER_MSG[]; | static const char _METHOD_ENTER_MSG[]; |
|
|
// 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. |
|
|
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); |
| |
|
|
// @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 |
|
|
// @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); |
| |
|
|
// @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); |
|
|
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); |
| |
|
|
| |
friend class TraceCallFrame; | friend class TraceCallFrame; |
friend class TracePropertyOwner; | friend class TracePropertyOwner; |
|
friend class TraceMemoryHandler; |
|
friend class TraceFileHandler; |
}; | }; |
| |
//============================================================================== | //============================================================================== |
|
|
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) |
{ | { |
|
|
// empty function | // empty function |
} | } |
| |
inline Uint32 Tracer::setTraceFacility(const String& traceComponents) |
inline Uint32 Tracer::setTraceFacility(const String& traceFacility) |
|
{ |
|
// 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 | // empty function |
|
return; |
} | } |
| |
#endif /* PEGASUS_REMOVE_TRACE */ | #endif /* PEGASUS_REMOVE_TRACE */ |
|
|
| |
# 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; \ |
|
|
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. |
|
|
| |
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, |
...) | ...) |