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.25 and 1.33

version 1.25, 2006/06/20 16:51:31

version 1.33, 2008/02/27 20:28:16

Line 29

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

// Author: Sushma Fernandes, Hewlett-Packard Company (sushma_fernandes@hp.com)

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

//%/////////////////////////////////////////////////////////////////////////////

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

Line 49

Line 42

#include <Pegasus/Common/TraceComponents.h>

#include <Pegasus/Common/TraceFileHandler.h>

#include <Pegasus/Common/Linkage.h>

#include <Pegasus/Common/AutoPtr.h>

#include <Pegasus/Common/SharedPtr.h>

PEGASUS_NAMESPACE_BEGIN

Line 80

Line 73

static const Uint32 LEVEL3;

static const Uint32 LEVEL4;

/** Traces the specified number of bytes in a given buffer

/** Traces the given character string.

@param traceComponent component being traced

Overloaded to include the filename

@param level 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 level,

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 level 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 level,

const char* data,

const Uint32 size);

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

@param string the string to be traced

static void trace(

static void traceCString(

const char* fileName,

const Uint32 lineNum,

const Uint32 traceComponent,

const Uint32 level,

const char* cstring);

const String& string);

/** Traces the given string.

@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 trace(

const Uint32 traceComponent,

const Uint32 level,

const String& string);

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

CIMException cimException);

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

Line 203

Line 140

/** Traces method entry.

@param token TracerToken

@param traceComponent component being traced

@param methodName method being traced

static void traceEnter(

TracerToken& token,

Uint32 component,

const char* method);

/** Traces method exit.

@param token TracerToken containing component and method

static void traceExit(

TracerToken& token);

/** Traces method entry.

@param token TracerToken

@param fileName filename of the trace originator

@param lineNum line number of the trace originator

@param traceComponent component being traced

Line 275

Line 196

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 303

Line 233

// Message Strings for Logger

static const char _LOG_MSG[];

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

// Traces the given message

// @param traceComponent component being traced

// @param level level of the trace message

// @param *fmt printf style format string

// @param argList variable argument list

static void _trace(

const Uint32 traceComponent,

const Uint32 level,

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.

// @param traceComponent component being traced

// @param level level of the trace message

// @param message message header (file name:line number)

// @param *fmt printf style format string

// @param argList variable argument list

Line 334

Line 243

const char* fileName,

const Uint32 lineNum,

const Uint32 traceComponent,

const Uint32 level,

const char* fmt,

va_list argList);

// Traces the specified number of bytes in a given buffer

// @param traceComponent component being traced

// @param level 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 level,

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 level 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 level,

const char* data,

const Uint32 size);

// Traces the given string.

// @param traceComponent component being traced

// @param level trace level of the trace message

// @param string the string to be traced

static void _traceString(

const Uint32 traceComponent,

const Uint32 level,

const String& string);

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

// @param CIMException the CIMException to be traced.

static void _traceCIMException(

const Uint32 traceComponent,

const Uint32 level,

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 *fmt printf style format string

// @param argList variable argument list

Line 416

Line 276

const char* fmt,

va_list argList);

// Traces method enter

// Traces method enter/exit

// @param fileName filename of the trace originator

// @param lineNum line number of the trace originator

// @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 Uint32 lineNum,

const Uint32 traceComponent,

const char* fmt,

...);

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

const char* methodEntryExit,

...);

const char* method);

// Tracer constructor

// Constructor is private to prevent construction of Tracer objects

Line 452

Line 299

// Returns the Singleton instance of the Tracer

// @return Tracer* Instance of Tracer

static Tracer* _getInstance();

friend class TraceCallFrame;

};

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

Line 463

Line 312

#ifdef PEGASUS_REMOVE_TRACE

inline void Tracer::traceBuffer(

inline void Tracer::traceCString(

const char* fileName,

const Uint32 lineNum,

const Uint32 traceComponent,

const Uint32 level,

const char* cstring)

const char* data,

const Uint32 size)

{

// empty function

}

inline void Tracer::traceBuffer(

inline void Tracer::traceCIMException(

const Uint32 traceComponent,

const Uint32 level,

const char* data,

const Uint32 size)

{

// empty function

}

inline void Tracer::trace(

const Uint32 traceComponent,

const Uint32 level,

const char *fmt,

...)

{

// empty function

}

inline void Tracer::trace(

const char* fileName,

const Uint32 lineNum,

const Uint32 traceComponent,

const Uint32 level,

const char* fmt,

const CIMException& cimException)

...)

{

// empty function

}

inline void Tracer::trace(

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::trace(

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

const Uint32 traceComponent,

const Uint32 level,

const String& string)

{

// empty function

return 0;

}

inline void Tracer::traceCIMException(

inline Uint32 Tracer::setTraceLevel(const Uint32 level)

const Uint32 traceComponent,

const Uint32 level,

CIMException cimException)

{

// empty function

return 0;

}

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

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

{

// empty function

return 0;

}

#endif /* PEGASUS_REMOVE_TRACE */

Line 559

Line 377

# 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; \

Tracer::traceEnter(__tracerToken PEGASUS_COMMA_FILE_LINE, comp, meth);

__tracerToken.method = 0; \

do \

{ \

if (Tracer::isTraceOn()) \

Tracer::traceEnter( \

__tracerToken PEGASUS_COMMA_FILE_LINE, comp, meth); \

} \

while (0)

# define PEG_METHOD_EXIT() \

Tracer::traceExit(__tracerToken PEGASUS_COMMA_FILE_LINE)

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 \

{ \

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

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 for Trace variable number of arguments with format string. The trace test

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

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

// as a single statement.

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

# define PEG_TRACE_CSTRING(comp, level, chars) \

// treated as a single statement.

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

Tracer::trace VAR_ARGS; \

{ \

TraceCallFrame frame(__FILE__, __LINE__); \

frame.invoke VAR_ARGS; \

} \

while (0)

Legend:

Removed from v.1.25
changed lines
	Added in v.1.33

No CVS admin address has been configured