version 1.1.2.3, 2001/08/01 23:13:01
|
version 1.33, 2008/02/27 20:28:16
|
|
|
//%///////////////////////////////////////////////////////////////////////////// |
//%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: |
|
// |
|
//%///////////////////////////////////////////////////////////////////////////// | //%///////////////////////////////////////////////////////////////////////////// |
| |
#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/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> |
|
#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: |
|
|
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 |
@param fileName filename of the trace originator |
|
@param lineNum line number of the trace originator |
inline static void trace( |
@param traceComponent component being traced |
const Uint32 traceComponent, |
@param cstring the character string to be traced |
const Uint32 traceLevel, |
*/ |
const char *fmt, |
static void traceCString( |
...) |
|
{ |
|
// empty function |
|
} |
|
|
|
inline static void trace( |
|
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* fmt, |
|
...) |
|
{ |
|
// empty function |
|
} |
|
| |
#else |
/** Traces the message in the given CIMException object. The message |
|
written to the trace file will include the source filename and |
/** Traces the given message |
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); |
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 |
| |
/** 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 traceLevel trace level of the trace message |
|
@param *fmt printf style format string |
|
@param ... variable argument list |
|
*/ | */ |
inline static void trace( |
static SharedArrayPtr<char> getHTTPRequestMessage( |
const char* fileName, |
const Buffer& requestMessage); |
const Uint32 lineNum, |
|
const Uint32 traceComponent, |
|
const Uint32 traceLevel, |
|
const char* fmt, |
|
...) |
|
{ |
|
va_list argList; |
|
| |
va_start(argList,fmt); |
/** Set the trace file to the given file |
_trace(fileName,lineNum,traceComponent,traceLevel,fmt,argList); |
@param traceFile full path of the trace file |
va_end(argList); |
@return 0 if the filepath is valid |
} |
1 if the traceFile is an empty string or |
|
if an error occurs while opening the file |
|
in append mode |
|
*/ |
|
static Uint32 setTraceFile(const char* traceFile); |
| |
#endif |
/** Set the trace level to the given level |
|
@param level trace level to be set |
|
@return 0 if trace level is valid |
|
1 if trace level is invalid |
|
*/ |
|
static Uint32 setTraceLevel(const Uint32 level); |
| |
// End of PEGASUS_REMOVE_TRACE |
/** Set components to be traced |
|
@param traceComponents list of components to be traced, |
|
components should be separated by ',' |
|
*/ |
|
static void setTraceComponents( |
|
const String& traceComponents); |
| |
/** 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); |
|
} |
|
| |
/** Set the trace file to the given file |
/** Validates the File Path for the trace File |
@param traceFile full path of the trace file |
@param filePath full path of the file |
@return 0 if the filepath is valid |
@return 1 if the file path is valid |
1 if an error occurs while opening the file in |
0 if the file path is invalid |
append mode |
|
*/ | */ |
static Uint32 setTraceFile(const char* traceFile); |
static Boolean isValidFileName(const char* filePath); |
| |
/** Set the trace level to the given level |
/** Validates the trace components |
@param traceLevel trace level to be set |
@param traceComponents comma separated list of trace components |
@return 0 if trace level is valid |
@return 1 if the components are valid |
1 if trace level is invalid |
0 if one or more components are invalid |
*/ | */ |
static Uint32 setTraceLevel(const Uint32 traceLevel); |
static Boolean isValidComponents(const String& traceComponents); |
| |
/** Set components to be traced |
/** Validates the trace components |
@param traceComponents list of components to be traced, components |
@param traceComponents comma separated list of trace components |
should be separated by ',' |
@param invalidComponents comma separated list of invalid components |
|
@return 1 if the components are valid |
|
0 if one or more components are invalid |
*/ | */ |
static void setTraceComponents(String traceComponents); |
static Boolean isValidComponents( |
|
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; } |
|
|
|
// 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 |
|
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; |
Boolean* _traceComponentMask; |
static const Uint32 _STRLEN_MAX_PID_TID; |
|
static const Boolean _SUCCESS; |
|
static const Boolean _FAILURE; |
|
AutoArrayPtr<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[]; |
|
|
|
// Checks if trace is enabled for the given component and trace level |
|
// @param traceComponent component being traced |
|
// @param traceLevel 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 traceLevel); |
|
|
|
// Traces the given message |
|
// @param traceComponent component being traced |
|
// @param traceLevel level of the trace message |
|
// @param *fmt printf style format string |
|
// @param argList variable argument list |
|
static void _trace( |
|
const Uint32 traceComponent, |
|
const Uint32 traceLevel, |
|
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 |
// @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); |
| |
// Called by all the trace interfaces to log message to the |
// Traces the message in the given CIMException object. The message |
// trace file |
// to be written to the trace file will include the source filename and |
// @param fileName filename of the trace originator |
// line number of the CIMException originator. |
// @param lineNum line number of the trace originator |
// @param traceComponent component being traced |
|
// @param CIMException the CIMException to be traced. |
|
// |
|
static void _traceCIMException( |
|
const Uint32 traceComponent, |
|
const CIMException& cimException); |
|
|
|
// Called by all the trace interfaces to log message |
|
// consisting of a single character string to the trace file |
|
// @param traceComponent component being traced |
|
// @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; |
}; | }; |
| |
// Define the macros for method entry/exit |
//============================================================================== |
|
// |
|
// 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) |
|
#else |
|
/** Macro for tracing method entry |
|
@param traceComponent component being traced |
|
@param methodName name of the method |
|
*/ |
|
#define PEG_FUNC_ENTER(traceComponent,methodName) \ |
|
Tracer::traceEnter(__FILE__, __LINE__,traceComponent,methodName) |
|
| |
/** Macro for tracing method exit |
inline void Tracer::traceCString( |
@param traceComponent component being traced |
const char* fileName, |
@param methodName name of the method |
const Uint32 lineNum, |
*/ |
const Uint32 traceComponent, |
#define PEG_FUNC_EXIT(traceComponent,methodName) \ |
const char* cstring) |
Tracer::traceExit(__FILE__,__LINE__,traceComponent,methodName) |
{ |
|
// 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 |
|
} |
|
|
|
#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 |
|
# define PEGASUS_COMMA_FILE_LINE ,__FILE__,__LINE__ |
|
# define PEGASUS_FILE_LINE_COMMA __FILE__,__LINE__, |
#endif | #endif |
| |
|
#ifdef PEGASUS_REMOVE_TRACE |
|
|
|
# define PEG_METHOD_ENTER(comp,meth) |
|
# define PEG_METHOD_EXIT() |
|
# define PEG_TRACE_STRING(comp,level,string) |
|
# define PEG_TRACE(VAR_ARGS) |
|
# define PEG_TRACE_CSTRING(comp,level,chars) |
|
|
|
#else /* PEGASUS_REMOVE_TRACE */ |
|
|
|
# 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) |
|
|
|
# define PEG_METHOD_EXIT() \ |
|
do \ |
|
{ \ |
|
if (Tracer::isTraceOn()) \ |
|
Tracer::traceExit(__tracerToken PEGASUS_COMMA_FILE_LINE); \ |
|
} \ |
|
while (0) |
|
|
|
// 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()) \ |
|
{ \ |
|
PEGASUS_ASSERT(level != Tracer::LEVEL1); \ |
|
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()) \ |
|
{ \ |
|
PEGASUS_ASSERT(level != Tracer::LEVEL1); \ |
|
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 */ |