version 1.6, 2002/03/09 01:17:10
|
version 1.36, 2008/05/27 17:32:57
|
|
|
//%///////////////////////////////////////////////////////////////////////////// |
//%2006//////////////////////////////////////////////////////////////////////// |
// | // |
// 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. |
|
// Copyright (c) 2006 Hewlett-Packard Development Company, L.P.; IBM Corp.; |
|
// EMC Corporation; Symantec 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 |
|
|
// | // |
//============================================================================== | //============================================================================== |
// | // |
// Author: Sushma Fernandes, Hewlett-Packard Company (sushma_fernandes@hp.com) |
|
// |
|
// Modified By: Jenny Yu, Hewlett-Packard Company (jenny_yu@hp.com) |
|
// |
|
//%///////////////////////////////////////////////////////////////////////////// | //%///////////////////////////////////////////////////////////////////////////// |
| |
#ifndef Pegasus_Tracer_h | #ifndef Pegasus_Tracer_h |
#define Pegasus_Tracer_h | #define Pegasus_Tracer_h |
| |
#include <stdarg.h> |
#include <cstdarg> |
#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/Exception.h> |
#include <Pegasus/Common/InternalException.h> |
#include <Pegasus/Common/TraceComponents.h> | #include <Pegasus/Common/TraceComponents.h> |
#include <Pegasus/Common/TraceFileHandler.h> |
#include <Pegasus/Common/TraceHandler.h> |
|
#include <Pegasus/Common/Linkage.h> |
// REVIEW: Ask how this all works (note to myself)? |
#include <Pegasus/Common/SharedPtr.h> |
| |
PEGASUS_NAMESPACE_BEGIN | PEGASUS_NAMESPACE_BEGIN |
| |
/** Tracer implements tracing of messages to a defined file |
/** Token used for tracing functions. |
*/ | */ |
|
struct TracerToken |
|
{ |
|
Uint32 component; |
|
const char* method; |
|
}; |
| |
|
/** Tracer implements tracing of messages to a defined file |
|
*/ |
class PEGASUS_COMMON_LINKAGE Tracer | class PEGASUS_COMMON_LINKAGE Tracer |
{ | { |
public: | public: |
| |
|
|
|
/** Trace facilities |
|
File - tracing occurs to the trace file |
|
Log - tracing occurs through the Pegasus Logger class |
|
Keep the TRACE_FACILITY_LIST in sync with the TRACE_FACILITY_INDEX, |
|
so that the index matches the according string in the list. |
|
*/ |
|
static char const* TRACE_FACILITY_LIST[]; |
|
|
|
enum TRACE_FACILITY_INDEX |
|
{ |
|
TRACE_FACILITY_FILE = 0, |
|
TRACE_FACILITY_LOG = 1 |
|
}; |
|
|
|
|
/** Levels of trace | /** Levels of trace |
Trace messages are written to the trace file only if they are at or | Trace messages are written to the trace file only if they are at or |
above a given trace level | above a given trace level |
LEVEL1 - Function Entry/Exit |
LEVEL1 - Severe and log messages |
LEVEL2 - Basic flow trace messages, low data detail | LEVEL2 - Basic flow trace messages, low data detail |
LEVEL3 - Inter-function logic flow, medium data detail | LEVEL3 - Inter-function logic flow, medium data detail |
LEVEL4 - High data detail | LEVEL4 - High data detail |
|
|
static const Uint32 LEVEL3; | static const Uint32 LEVEL3; |
static const Uint32 LEVEL4; | static const Uint32 LEVEL4; |
| |
// PEGASUS_REMOVE_TRACE defines the compile time inclusion of the Trace |
/** Traces the given character string. |
// interfaces. If defined the interfaces map to empty functions |
Overloaded to include the filename |
|
and line number of trace origin. |
#ifdef PEGASUS_REMOVE_TRACE |
|
|
|
inline static void traceBuffer( |
|
const char* fileName, |
|
const Uint32 lineNum, |
|
const Uint32 traceComponent, |
|
const Uint32 traceLevel, |
|
const char* data, |
|
const Uint32 size) |
|
{ |
|
// empty function |
|
} |
|
inline static void traceBuffer( |
|
const Uint32 traceComponent, |
|
const Uint32 traceLevel, |
|
const char* data, |
|
const Uint32 size) |
|
{ |
|
// empty function |
|
} |
|
|
|
inline static void trace( |
|
const Uint32 traceComponent, |
|
const Uint32 traceLevel, |
|
const char *fmt, |
|
...) |
|
{ |
|
// empty function |
|
} |
|
|
|
inline static void trace( |
|
const char* fileName, |
|
const Uint32 lineNum, |
|
const Uint32 traceComponent, |
|
const Uint32 traceLevel, |
|
const char* fmt, |
|
...) |
|
{ |
|
// 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) |
|
{ |
|
// empty function |
|
return 0; |
|
} |
|
|
|
static Uint32 setTraceLevel(const Uint32 traceLevel) |
|
{ |
|
// empty function |
|
return 0; |
|
} |
|
|
|
static void setTraceComponents( |
|
const String traceComponents) |
|
{ |
|
// empty function |
|
} |
|
|
|
|
|
#else |
|
/** Traces the specified number of bytes in a given buffer |
|
@param traceComponent component being traced |
|
@param traceLevel trace level of the trace message |
|
@param data buffer to be traced |
|
@param size number of bytes to be traced |
|
*/ |
|
inline static void traceBuffer( |
|
const Uint32 traceComponent, |
|
const Uint32 traceLevel, |
|
const char* data, |
|
const Uint32 size) |
|
{ |
|
_traceBuffer( traceComponent, traceLevel, data, size ); |
|
} |
|
|
|
/** Traces the specified number of bytes in a given buffer |
|
Overloaded to include the filename and the 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 traceLevel trace level of the trace message |
@param cstring the character string to be traced |
@param data buffer to be traced |
|
@param size size of the buffer |
|
*/ | */ |
inline static void traceBuffer( |
static void traceCString( |
const char* fileName, | const char* fileName, |
const Uint32 lineNum, | const Uint32 lineNum, |
const Uint32 traceComponent, | const Uint32 traceComponent, |
const Uint32 traceLevel, |
const char* cstring); |
const char* data, |
|
const Uint32 size) |
|
{ |
|
_traceBuffer( fileName, lineNum, |
|
traceComponent, traceLevel, data, size ); |
|
} |
|
| |
|
/** Traces the message in the given CIMException object. The message |
/** Traces the given message |
written to the trace file will include the source filename and |
|
line number of the CIMException originator. |
@param traceComponent component being traced | @param traceComponent component being traced |
@param traceLevel trace level of the trace message |
@param level trace level of the trace message |
@param *fmt printf style format string |
@param cimException the CIMException to be traced. |
@param ... variable argument list |
|
*/ | */ |
inline static void trace( |
static void traceCIMException( |
const Uint32 traceComponent, | const Uint32 traceComponent, |
const Uint32 traceLevel, |
const Uint32 level, |
const char *fmt, |
const CIMException& cimException); |
...) |
|
{ |
|
va_list argList; |
|
| |
va_start(argList,fmt); |
/** Gets an HTTP request message. |
_trace(traceComponent,traceLevel,fmt,argList); |
|
va_end(argList); |
|
} |
|
| |
/** Traces the given message. Overloaded to include the filename and |
Given an HTTP request message, this method checks if the |
the line number of trace origin. |
message contains a "Basic" authorization header. |
@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 *fmt printf style format string |
|
@param ... variable argument list |
|
*/ |
|
inline static void trace( |
|
const char* fileName, |
|
const Uint32 lineNum, |
|
const Uint32 traceComponent, |
|
const Uint32 traceLevel, |
|
const char* fmt, |
|
...) |
|
{ |
|
va_list argList; |
|
| |
va_start(argList,fmt); |
If true, the username/passwd is suppressed and returned. |
_trace(fileName,lineNum,traceComponent,traceLevel,fmt,argList); |
Otherwise the request message is returned without any changes. |
va_end(argList); |
|
} |
|
| |
/** Traces the given string. Overloaded to include the filename |
@param requestMessage requestMessage to be checked |
and line number of trace origin. |
|
@param fileName filename of the trace originator |
@return request message |
@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) |
|
{ |
|
_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( |
static SharedArrayPtr<char> getHTTPRequestMessage( |
const Uint32 traceComponent, |
const Buffer& requestMessage); |
const Uint32 traceLevel, |
|
CIMException cimException) |
|
{ |
|
_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); |
| |
/** Set the trace level to the given level | /** Set the trace level to the given level |
@param traceLevel trace level to be set |
@param level trace level to be set |
@return 0 if trace level is valid | @return 0 if trace level is valid |
1 if trace level is invalid | 1 if trace level is invalid |
*/ | */ |
static Uint32 setTraceLevel(const Uint32 traceLevel); |
static Uint32 setTraceLevel(const Uint32 level); |
| |
/** Set components to be traced | /** Set components to be traced |
@param traceComponents list of components to be traced, | @param traceComponents list of components to be traced, |
components should be separated by ',' | components should be separated by ',' |
*/ | */ |
static void setTraceComponents( | static void setTraceComponents( |
const String traceComponents); |
const String& traceComponents); |
| |
#endif |
/** Set trace facility to be used |
|
@param traceFacility facility to be used for tracing, |
// End of PEGASUS_REMOVE_TRACE |
for example Log or File. |
|
@return 0 if trace facility is valid |
|
1 if trace facility is invalid |
|
*/ |
|
static Uint32 setTraceFacility(const String& traceFacility); |
| |
/** Traces method entry. | /** Traces method entry. |
|
@param token TracerToken |
@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 methodName method being traced | @param methodName method being traced |
*/ | */ |
inline static void traceEnter( |
static void traceEnter( |
const char* fileName, |
TracerToken& token, |
const Uint32 lineNum, |
const char* file, |
const Uint32 traceComponent, |
size_t line, |
const char* methodName) |
Uint32 component, |
{ |
const char* method); |
_traceEnter( fileName, lineNum, traceComponent, "%s %s", |
|
_FUNC_ENTER_MSG, methodName); |
|
} |
|
| |
/** Traces method exit. | /** Traces method exit. |
|
@param token TracerToken containing component and method |
@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 methodName method being traced |
|
*/ | */ |
inline static void traceExit( |
static void traceExit( |
const char* fileName, |
TracerToken& token, |
const Uint32 lineNum, |
const char* file, |
const Uint32 traceComponent, |
size_t line); |
const char* methodName) |
|
{ |
|
_traceExit( fileName, lineNum, traceComponent, "%s %s", |
|
_FUNC_EXIT_MSG, methodName); |
|
} |
|
| |
/** Validates the File Path for the trace File | /** Validates the File Path for the trace File |
@param filePath full path of the file | @param filePath full path of the file |
@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 | /** Validates the trace components |
@param traceComponents comma separated list of trace components | @param traceComponents comma separated list of trace components |
@param invalidComponents comma separated list of invalid components |
|
@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); |
const String traceComponents, String& invalidComponents=_EMPTY_STRING); |
|
| |
private: |
/** Validates the trace components |
|
@param traceComponents comma separated list of trace components |
|
@param invalidComponents comma separated list of invalid components |
|
@return 1 if the components are valid |
|
0 if one or more components are invalid |
|
*/ |
|
static Boolean isValidComponents( |
|
const String& traceComponents, |
|
String& invalidComponents); |
| |
static const char _COMPONENT_SEPARATOR; |
/** Validates the trace facility string value |
static const Uint32 _NUM_COMPONENTS; |
@param traceFacility The trace facility as string |
static const Uint32 _STRLEN_MAX_UNSIGNED_INT; |
@return 1 if the trace facility is valid |
static const Uint32 _STRLEN_MAX_PID_TID; |
0 if the trace facility is invalid |
static const Boolean _SUCCESS; |
*/ |
static const Boolean _FAILURE; |
static Boolean isValidTraceFacility( const String& traceFacility ); |
static String _EMPTY_STRING; |
|
Boolean* _traceComponentMask; |
|
Uint32 _traceLevelMask; |
|
TraceFileHandler* _traceHandler; |
|
static Tracer* _tracerInstance; |
|
| |
// Message Strings for fucntion Entry and Exit |
/** Specify the name of the module being traced. If non-empty, this |
static const char _FUNC_ENTER_MSG[]; |
value is used as an extension to the name of the trace file. |
static const char _FUNC_EXIT_MSG[]; |
@param moduleName Name of the module being traced. |
|
*/ |
|
static void setModuleName(const String& moduleName); |
| |
// Message Strings for Logger |
/** |
static const char _LOG_MSG[]; |
*/ |
|
static Boolean isTraceOn() { return _traceOn; } |
| |
// 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 |
// @param traceLevel level of the trace message |
// @param level level of the trace message |
// @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 Uint32 traceComponent, |
const Uint32 traceLevel); |
const Uint32 level); |
| |
// Traces the given message |
private: |
// @param traceComponent component being traced |
|
// @param traceLevel level of the trace message |
/** A static single indicator if tracing is turned on allowing to |
// @param *fmt printf style format string |
determine the state of trace quickly without many instructions. |
// @param argList variable argument list |
Used to wrap the public static trace interface methods to avoid |
static void _trace( |
obsolete calls when tracing is turned off. |
const Uint32 traceComponent, |
*/ |
const Uint32 traceLevel, |
static Boolean _traceOn; |
const char* fmt, |
|
va_list argList); |
/** Internal only Levels of trace |
|
These cannot be used in any of the trace calls directly, but are set |
|
by methods of the Tracer class for specific purposes, such as trace |
|
Enter and traceExit. |
|
LEVEL0 - Trace is switched off |
|
LEVEL5 - used for method enter & exit |
|
*/ |
|
static const Uint32 LEVEL0; |
|
static const Uint32 LEVEL5; |
|
|
|
static const char _COMPONENT_SEPARATOR; |
|
static const Uint32 _NUM_COMPONENTS; |
|
static const Uint32 _STRLEN_MAX_UNSIGNED_INT; |
|
static const Uint32 _STRLEN_MAX_PID_TID; |
|
AutoArrayPtr<Boolean> _traceComponentMask; |
|
Uint32 _traceFacility; |
|
//Is true if any components are set at the component mask |
|
Boolean _componentsAreSet; |
|
Uint32 _traceLevelMask; |
|
AutoPtr<TraceHandler> _traceHandler; |
|
String _moduleName; |
|
static Tracer* _tracerInstance; |
|
|
|
// Message Strings for function Entry and Exit |
|
static const char _METHOD_ENTER_MSG[]; |
|
static const char _METHOD_EXIT_MSG[]; |
|
|
|
// Factory function to create an instance of the matching trace handler |
|
// for the given type of traceFacility. |
|
// @param traceFacility type of trace handler to create |
|
// @return an instance of a trace handler class. For invalid trace |
|
// facilities always creates a traceFileHandler. |
|
TraceHandler* getTraceHandler( Uint32 traceFacility ); |
| |
// 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 |
// @param traceLevel level of the trace message |
|
// @param message message header (file name:line number) | // @param message message header (file name:line number) |
// @param *fmt printf style format string | // @param *fmt printf style format string |
// @param argList variable argument list | // @param argList variable argument list |
|
|
const char* fileName, | const char* fileName, |
const Uint32 lineNum, | const Uint32 lineNum, |
const Uint32 traceComponent, | const Uint32 traceComponent, |
const Uint32 traceLevel, |
|
const char* fmt, | const char* fmt, |
va_list argList); | va_list argList); |
| |
// Traces the specified number of bytes in a given buffer |
|
// @param traceComponent component being traced |
|
// @param traceLevel trace level of the trace message |
|
// @param data buffer to be traced |
|
// @param size number of bytes to be traced |
|
static void _traceBuffer( |
|
const Uint32 traceComponent, |
|
const Uint32 traceLevel, |
|
const char* data, |
|
const Uint32 size); |
|
|
|
// Traces the specified number of bytes in a given buffer |
|
// 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 traceLevel trace level of the trace message |
|
// @param data buffer to be traced |
|
// @param size size of the buffer |
|
static void _traceBuffer( |
|
const char* fileName, |
|
const Uint32 lineNum, |
|
const Uint32 traceComponent, |
|
const Uint32 traceLevel, |
|
const char* data, |
|
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 | // 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. |
// @param traceComponent component being traced | // @param traceComponent component being traced |
// @param traceLevel 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, |
const Uint32 traceLevel, |
const CIMException& cimException); |
CIMException cimException); |
|
| |
// Called by all the trace interfaces to log message to the |
// Called by all the trace interfaces to log message |
// trace file |
// consisting of a single character string to the trace file |
// @param fileName filename of the trace originator |
// @param traceComponent component being traced |
// @param lineNum line number of the trace originator |
// @param cstring the string to be traced |
|
static void _traceCString( |
|
const Uint32 traceComponent, |
|
const char* message, |
|
const char* cstring); |
|
|
|
// Called by all the trace interfaces to log message |
|
// with variable number of arguments to the trace file |
// @param traceComponent component being traced | // @param traceComponent component being traced |
// @param *fmt printf style format string | // @param *fmt printf style format string |
// @param argList variable argument list | // @param argList variable argument list |
|
|
const char* fmt, | const char* fmt, |
va_list argList); | va_list argList); |
| |
// Traces method enter |
// Traces method enter/exit |
// @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 *fmt printf style format string |
// @param method name of the method |
// @param ... variable argument list |
static void _traceMethod( |
static void _traceEnter( |
|
const char* fileName, | const char* fileName, |
const Uint32 lineNum, | const Uint32 lineNum, |
const Uint32 traceComponent, | const Uint32 traceComponent, |
const char* fmt, |
const char* methodEntryExit, |
...); |
const char* method); |
|
|
// Traces method exit |
|
// @param fileName filename of the trace originator |
|
// @param traceComponent component being traced |
|
// @param *fmt printf style format string |
|
// @param ... variable argument list |
|
static void _traceExit( |
|
const char* fileName, |
|
const Uint32 lineNum, |
|
const Uint32 traceComponent, |
|
const char* fmt, |
|
...); |
|
| |
// Tracer constructor | // Tracer constructor |
// Constructor is private to prevent construction of Tracer objects | // Constructor is private to prevent construction of Tracer objects |
|
|
// 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; |
|
friend class TracePropertyOwner; |
}; | }; |
| |
// Define the macros for method entry/exit, and tracing a given string |
//============================================================================== |
|
// |
|
// PEGASUS_REMOVE_TRACE defines the compile time inclusion of the Trace |
|
// interfaces. If defined the interfaces map to empty functions. |
|
// |
|
//============================================================================== |
|
|
#ifdef PEGASUS_REMOVE_TRACE | #ifdef PEGASUS_REMOVE_TRACE |
#define PEG_FUNC_ENTER(traceComponent,methodName) |
|
#define PEG_FUNC_EXIT(traceComponent,methodName) |
inline void Tracer::traceCString( |
#define PEG_METHOD_ENTER(traceComponent,methodName) |
const char* fileName, |
#define PEG_METHOD_EXIT() |
const Uint32 lineNum, |
#define PEG_TRACE_STRING(traceComponent,traceLevel,traceString) |
const Uint32 traceComponent, |
|
const char* cstring) |
|
{ |
|
// empty function |
|
} |
|
|
|
inline void Tracer::traceCIMException( |
|
const Uint32 traceComponent, |
|
const Uint32 level, |
|
const CIMException& cimException) |
|
{ |
|
// empty function |
|
} |
|
|
|
static SharedArrayPtr<char> getHTTPRequestMessage( |
|
const Buffer& requestMessage) |
|
{ |
|
//empty function |
|
return SharedArrayPtr<char>(); |
|
} |
|
|
|
inline Uint32 Tracer::setTraceFile(const char* traceFile) |
|
{ |
|
// empty function |
|
return 0; |
|
} |
|
|
|
inline Uint32 Tracer::setTraceLevel(const Uint32 level) |
|
{ |
|
// empty function |
|
return 0; |
|
} |
|
|
|
inline void Tracer::setTraceComponents(const String& traceComponents) |
|
{ |
|
// empty function |
|
} |
|
|
|
inline Uint32 Tracer::setTraceFacility(const String& traceComponents) |
|
{ |
|
// empty function |
|
} |
|
|
|
#endif /* PEGASUS_REMOVE_TRACE */ |
|
|
|
//============================================================================== |
|
// |
|
// Tracing macros |
|
// |
|
//============================================================================== |
|
|
|
// Defines a variable that bypasses inclusion of line and filename in output. |
|
// #define PEGASUS_NO_FILE_LINE_TRACE=1 to exclude file names and line numbers |
|
#ifdef PEGASUS_NO_FILE_LINE_TRACE |
|
# define PEGASUS_COMMA_FILE_LINE /* empty */ |
|
# define PEGASUS_FILE_LINE_COMMA /* empty */ |
#else | #else |
/** Macro for tracing method entry |
# define PEGASUS_COMMA_FILE_LINE ,__FILE__,__LINE__ |
ATTN: Phase out in favor of PEG_METHOD_ENTER |
# define PEGASUS_FILE_LINE_COMMA __FILE__,__LINE__, |
@param traceComponent component being traced |
#endif |
@param methodName name of the method |
|
*/ |
|
#define PEG_FUNC_ENTER(traceComponent,methodName) \ |
|
Tracer::traceEnter(__FILE__, __LINE__,traceComponent,methodName) |
|
| |
/** Macro for tracing method exit |
#ifdef PEGASUS_REMOVE_TRACE |
ATTN: Phase out in favor of PEG_METHOD_EXIT |
|
@param traceComponent component being traced |
|
@param methodName name of the method |
|
*/ |
|
#define PEG_FUNC_EXIT(traceComponent,methodName) \ |
|
Tracer::traceExit(__FILE__,__LINE__,traceComponent,methodName) |
|
| |
/** Macro for tracing method entry |
# define PEG_METHOD_ENTER(comp,meth) |
@param traceComponent component being traced |
# define PEG_METHOD_EXIT() |
@param methodName name of the method |
# define PEG_TRACE_STRING(comp,level,string) |
*/ |
# define PEG_TRACE(VAR_ARGS) |
#define PEG_METHOD_ENTER(traceComponent,methodName) \ |
# define PEG_TRACE_CSTRING(comp,level,chars) |
const char *PEG_METHOD_NAME = methodName; \ |
|
const Uint32 PEG_TRACE_COMPONENT = traceComponent; \ |
#else /* PEGASUS_REMOVE_TRACE */ |
Tracer::traceEnter(__FILE__,__LINE__,PEG_TRACE_COMPONENT,PEG_METHOD_NAME) |
|
|
// 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) \ |
|
TracerToken __tracerToken; \ |
|
__tracerToken.method = 0; \ |
|
do \ |
|
{ \ |
|
if (Tracer::isTraceOn()) \ |
|
Tracer::traceEnter( \ |
|
__tracerToken PEGASUS_COMMA_FILE_LINE, comp, meth); \ |
|
} \ |
|
while (0) |
| |
/** Macro for tracing method exit |
|
*/ |
|
#define PEG_METHOD_EXIT() \ | #define PEG_METHOD_EXIT() \ |
Tracer::traceExit(__FILE__,__LINE__,PEG_TRACE_COMPONENT,PEG_METHOD_NAME) |
do \ |
|
{ \ |
/** Macro for tracing a string |
if (Tracer::isTraceOn()) \ |
@param traceComponent component being traced |
Tracer::traceExit(__tracerToken PEGASUS_COMMA_FILE_LINE); \ |
@param traceLevel trace level of the trace message |
} \ |
@param traceString the string to be traced |
while (0) |
*/ |
|
#define PEG_TRACE_STRING(traceComponent,traceLevel,traceString) \ |
|
Tracer::trace(__FILE__, __LINE__,traceComponent,traceLevel,traceString) |
|
#endif | #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 |
|
// as a single statement. |
|
# define PEG_TRACE_CSTRING(comp, level, chars) \ |
|
do \ |
|
{ \ |
|
if (Tracer::isTraceOn()) \ |
|
{ \ |
|
if (Tracer::isTraceEnabled(comp, level)) \ |
|
{ \ |
|
Tracer::traceCString(PEGASUS_FILE_LINE_COMMA comp, chars); \ |
|
} \ |
|
} \ |
|
} \ |
|
while (0) |
|
|
|
// |
|
// This class is constructed with the same arguments passed to PEG_TRACE(). |
|
// The constructor saves all the fixed arguments and calls va_start() on |
|
// 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) \ |
|
do \ |
|
{ \ |
|
if (Tracer::isTraceOn()) \ |
|
{ \ |
|
TraceCallFrame frame(__FILE__, __LINE__); \ |
|
frame.invoke VAR_ARGS; \ |
|
} \ |
|
} \ |
|
while (0) |
|
|
|
#endif /* !PEGASUS_REMOVE_TRACE */ |
|
|
PEGASUS_NAMESPACE_END | PEGASUS_NAMESPACE_END |
| |
#endif /* Pegasus_Tracer_h */ | #endif /* Pegasus_Tracer_h */ |