pegasus/src/Pegasus/Common/Tracer.h - diff

Return to Tracer.h CVS log

Up to [Pegasus] / pegasus / src / Pegasus / Common

Diff for /pegasus/src/Pegasus/Common/Tracer.h between version 1.29 and 1.38

version 1.29, 2007/03/28 19:34:53

version 1.38, 2008/08/28 17:24:36

Line 34

#ifndef Pegasus_Tracer_h

#define Pegasus_Tracer_h

#include <stdarg.h>

#include <cstdarg>

#include <Pegasus/Common/String.h>

#include <Pegasus/Common/System.h>

#include <Pegasus/Common/Logger.h>

#include <Pegasus/Common/InternalException.h>

#include <Pegasus/Common/TraceComponents.h>

#include <Pegasus/Common/TraceFileHandler.h>

#include <Pegasus/Common/TraceHandler.h>

#include <Pegasus/Common/Linkage.h>

#include <Pegasus/Common/AutoPtr.h>

#include <Pegasus/Common/SharedPtr.h>

PEGASUS_NAMESPACE_BEGIN

Line 60

{

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

Trace messages are written to the trace file only if they are at or

above a given trace level

LEVEL1 - Function Entry/Exit

LEVEL1 - Severe and log messages

LEVEL2 - Basic flow trace messages, low data detail

LEVEL3 - Inter-function logic flow, medium data detail

LEVEL4 - High data detail

Line 73

Line 89

static const Uint32 LEVEL3;

static const Uint32 LEVEL4;

/** Traces the given message

@param traceComponent component being traced

@param level trace level of the trace message

@param *fmt printf style format string

@param ... variable argument list

static void trace(

const Uint32 traceComponent,

const Uint32 level,

const char *fmt,

...);

/** 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 level trace level of the trace message

@param *fmt printf style format string

@param ... variable argument list

static void trace(

const char* fileName,

const Uint32 lineNum,

const Uint32 traceComponent,

const Uint32 level,

const char* fmt,

...);

/** 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 level trace level of the trace message

@param string the string to be traced

static void traceString(

const char* fileName,

const Uint32 lineNum,

const Uint32 traceComponent,

const Uint32 level,

const String& string);

/** Traces the given character 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 level trace level of the trace message

@param cstring the character string to be traced

static void traceCString(

const char* fileName,

const Uint32 lineNum,

const Uint32 traceComponent,

const Uint32 level,

const char* cstring);

/** Traces the message in the given CIMException object. The message

Line 138

Line 108

line number of the CIMException originator.

@param traceComponent component being traced

@param level trace level of the trace message

@param CIMException the CIMException to be traced.

@param cimException the CIMException to be traced.

static void traceCIMException(

const Uint32 traceComponent,

const Uint32 level,

const CIMException& cimException);

/** Gets an HTTP request message.

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

static SharedArrayPtr<char> getHTTPRequestMessage(

const Buffer& requestMessage);

/** Set the trace file to the given file

@param traceFile full path of the trace file

@return 0 if the filepath is valid

Line 168

Line 154

static void setTraceComponents(

const String& traceComponents);

/** Set trace facility to be used

@param traceFacility facility to be used for tracing,

for example Log or File.

@return 0 if trace facility is valid

1 if trace facility is invalid

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

static Uint32 getTraceFacility();

/** Traces method entry.

@param token TracerToken

@param fileName filename of the trace originator

Line 216

const String& traceComponents,

String& invalidComponents);

/** Validates the trace facility string value

@param traceFacility The trace facility as string

@return 1 if the trace facility is valid

0 if the trace facility is invalid

static Boolean isValidTraceFacility( const String& traceFacility );

/** 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.

Line 226

Line 233

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:

/** A static single indicator if tracing is turned on allowing to

Line 235

Line 251

static Boolean _traceOn;

/** 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;

static const Boolean _SUCCESS;

static const Boolean _FAILURE;

AutoArrayPtr<Boolean> _traceComponentMask;

Uint32 _traceFacility;

//Is true if any components are set at the component mask

Boolean _componentsAreSet;

Uint32 _traceLevelMask;

AutoPtr<TraceFileHandler> _traceHandler;

AutoPtr<TraceHandler> _traceHandler;

String _moduleName;

static Tracer* _tracerInstance;

Line 251

Line 278

static const char _METHOD_ENTER_MSG[];

static const char _METHOD_EXIT_MSG[];

// Message Strings for Logger

// Factory function to create an instance of the matching trace handler

static const char _LOG_MSG[];

// for the given type of traceFacility.

// @param traceFacility type of trace handler to create

// Checks if trace is enabled for the given component and trace level

// @return an instance of a trace handler class. For invalid trace

// @param traceComponent component being traced

// facilities always creates a traceFileHandler.

// @param level level of the trace message

TraceHandler* getTraceHandler( Uint32 traceFacility );

// @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);

// Traces the given message

// @param traceComponent component being traced

// @param *fmt printf style format string

// @param argList variable argument list

static void _trace(

const Uint32 traceComponent,

const char* fmt,

va_list argList);

// Traces the given message. Overloaded to include the file name and the

// line number as one of the parameters.

Line 285

Line 298

const char* fmt,

va_list argList);

// Traces a given character 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 cstring the character string to be traced

static void _traceCString(

const char* fileName,

const Uint32 lineNum,

const Uint32 traceComponent,

const char* cstring);

// 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.

Line 351

// Returns the Singleton instance of the Tracer

// @return Tracer* Instance of Tracer

static Tracer* _getInstance();

friend class TraceCallFrame;

friend class TracePropertyOwner;

};

//==============================================================================

Line 362

Line 365

#ifdef PEGASUS_REMOVE_TRACE

inline void Tracer::trace(

inline void Tracer::traceCString(

const char* fileName,

const Uint32 lineNum,

const Uint32 traceComponent,

const Uint32 level,

const char* cstring)

const char *fmt,

...)

{

// empty function

}

inline void Tracer::trace(

inline void Tracer::traceCIMException(

const char* fileName,

const Uint32 lineNum,

const Uint32 traceComponent,

const Uint32 level,

const char* fmt,

const CIMException& cimException)

...)

{

// empty function

}

inline void Tracer::traceString(

static SharedArrayPtr<char> getHTTPRequestMessage(

const char* fileName,

const Buffer& requestMessage)

const Uint32 lineNum,

const Uint32 traceComponent,

const Uint32 level,

const String& string)

{

// empty function

return SharedArrayPtr<char>();

}

inline void Tracer::traceCString(

inline Uint32 Tracer::setTraceFile(const char* traceFile)

const char* fileName,

const Uint32 lineNum,

const Uint32 traceComponent,

const Uint32 level,

const char* cstring)

{

// empty function

return 0;

}

inline void Tracer::traceCIMException(

inline Uint32 Tracer::setTraceLevel(const Uint32 level)

const Uint32 traceComponent,

const Uint32 level,

const CIMException& cimException)

{

// empty function

return 0;

}

inline Uint32 Tracer::setTraceFile(const char* traceFile)

inline void Tracer::setTraceComponents(const String& traceComponents)

{

// empty function

return 0;

}

inline Uint32 Tracer::setTraceLevel(const Uint32 level)

inline Uint32 Tracer::setTraceFacility(const String& traceComponents)

{

// empty function

return 0;

}

inline void Tracer::setTraceComponents(const String& traceComponents)

inline Uint32 Tracer::getTraceFacility()

{

// empty function

return 0;

}

#endif /* PEGASUS_REMOVE_TRACE */

Line 449

Line 440

# 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 */

// 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()) \

Line 472

Line 468

Tracer::traceExit(__tracerToken PEGASUS_COMMA_FILE_LINE); \

} \

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()) \

Tracer::traceString(PEGASUS_FILE_LINE_COMMA comp, level, string); \

} \

while (0)

// Macro to trace character lists. the do construct allows this to appear

// as a single statement.

Line 489

Line 476

do \

{ \

if (Tracer::isTraceOn()) \

Tracer::traceCString(PEGASUS_FILE_LINE_COMMA comp, level, chars); \

{ \

if (Tracer::isTraceEnabled(comp, level)) \

{ \

Tracer::traceCString(PEGASUS_FILE_LINE_COMMA comp, chars); \

} \

while (0)

// Macro for Trace variable number of arguments with format string. The trace

// test is included becase of the possible cost of preparing the variable

// This class is constructed with the same arguments passed to PEG_TRACE().

// number of arguments on each call. The d construct allows this to be

// The constructor saves all the fixed arguments and calls va_start() on

// treated as a single statement.

// 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()) \

Tracer::trace VAR_ARGS; \

{ \

TraceCallFrame frame(__FILE__, __LINE__); \

frame.invoke VAR_ARGS; \

} \

while (0)

Legend:

Removed from v.1.29
changed lines
	Added in v.1.38

No CVS admin address has been configured