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.21 and 1.31

version 1.21, 2005/11/18 21:19:11

version 1.31, 2007/06/15 17:35:47

Line 1

//%2005////////////////////////////////////////////////////////////////////////

//%2006////////////////////////////////////////////////////////////////////////

// Company, L.P.; IBM Corp.; The Open Group; Tivoli Systems.

Line 8

// IBM Corp.; EMC Corporation; VERITAS Software Corporation; The Open Group.

// EMC Corporation; VERITAS Software Corporation; The Open Group.

// EMC Corporation; Symantec Corporation; The Open Group.

// Permission is hereby granted, free of charge, to any person obtaining a copy

// of this software and associated documentation files (the "Software"), to

Line 27

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)

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

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

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

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

{

public:

Line 70

Line 73

static const Uint32 LEVEL3;

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)

{

if (_traceOn)

{

_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 lineNum line number of the trace originator

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

const Uint32 traceComponent,

const Uint32 traceLevel,

const char* cstring);

const char* data,

const Uint32 size)

{

if (_traceOn)

{

_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 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 traceLevel,

const Uint32 level,

const char *fmt,

const CIMException& cimException);

...)

{

if (_traceOn)

{

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,

...)

{

if (_traceOn)

{

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)

{

if (_traceOn)

{

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

{

if (_traceOn)

{

_traceCIMException( traceComponent, traceLevel, cimException );

}

/** Set the trace file to the given file

@param traceFile full path of the trace file

Line 295

Line 125

static Uint32 setTraceFile(const char* traceFile);

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

1 if trace level is invalid

static Uint32 setTraceLevel(const Uint32 traceLevel);

static Uint32 setTraceLevel(const Uint32 level);

/** Set components to be traced

@param traceComponents list of components to be traced,

Line 308

Line 138

static void setTraceComponents(

const String& traceComponents);

#endif

// End of PEGASUS_REMOVE_TRACE

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

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

if (_traceOn)

{

_traceEnter( fileName, lineNum, traceComponent, "%s %s",

_METHOD_ENTER_MSG, methodName);

}

/** Traces method exit.

@param token TracerToken containing component and method

@param fileName filename 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)

{

if (_traceOn)

{

_traceExit( fileName, lineNum, traceComponent, "%s %s",

_METHOD_EXIT_MSG, methodName);

}

/** Validates the File Path for the trace File

@param filePath full path of the file

Line 380

Line 192

static void setModuleName(const String& moduleName);

static bool isTraceOn() { return _traceOn; }

/**

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:

Line 389

Line 212

Used to wrap the public static trace interface methods to avoid

obsolete calls when tracing is turned off.

static Uint32 _traceOn;

static Boolean _traceOn;

static const char _COMPONENT_SEPARATOR;

static const Uint32 _NUM_COMPONENTS;

Line 410

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

// line number as one of the parameters.

// @param traceComponent component being traced

// @param traceLevel 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 441

Line 243

const char* fileName,

const Uint32 lineNum,

const Uint32 traceComponent,

const Uint32 traceLevel,

const char* fmt,

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

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

// @param CIMException the CIMException to be traced.

static void _traceCIMException(

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

// @param argList variable argument list

Line 523

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 559

Line 299

// Returns the Singleton instance of the Tracer

// @return Tracer* Instance of Tracer

static Tracer* _getInstance();

friend class TraceCallFrame;

};

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

#define PEG_METHOD_ENTER(traceComponent,methodName)

#define PEG_METHOD_EXIT()

inline void Tracer::traceCString(

#define PEG_TRACE_STRING(traceComponent,traceLevel,traceString)

const char* fileName,

const Uint32 lineNum,

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

}

#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

/** Macro for tracing method entry

# define PEGASUS_COMMA_FILE_LINE ,__FILE__,__LINE__

@param traceComponent component being traced

# define PEGASUS_FILE_LINE_COMMA __FILE__,__LINE__,

@param methodName name of the method

#endif

#define PEG_METHOD_ENTER(traceComponent,methodName) \

#ifdef PEGASUS_REMOVE_TRACE

const char *PEG_METHOD_NAME = methodName; \

const Uint32 PEG_TRACE_COMPONENT = traceComponent; \

# define PEG_METHOD_ENTER(comp,meth)

Tracer::traceEnter(__FILE__,__LINE__,PEG_TRACE_COMPONENT,PEG_METHOD_NAME)

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

do \

{ \

if (Tracer::isTraceOn()) \

Tracer::traceEnter( \

__tracerToken PEGASUS_COMMA_FILE_LINE, comp, meth); \

} \

while (0)

/** Macro for tracing method exit

#define PEG_METHOD_EXIT() \

Tracer::traceExit(__FILE__,__LINE__,PEG_TRACE_COMPONENT,PEG_METHOD_NAME)

do \

{ \

if (Tracer::isTraceOn()) \

Tracer::traceExit(__tracerToken PEGASUS_COMMA_FILE_LINE); \

} \

while (0)

/** Macro for tracing a string

// Macro for Trace String. the do construct allows this to appear

@param traceComponent component being traced

// as a single statement.

@param traceLevel trace level of the trace message

# define PEG_TRACE_STRING(comp, level, string) \

@param traceString the string to be traced

#define PEG_TRACE_STRING(traceComponent,traceLevel,traceString) \

do \

{ \

if (Tracer::isTraceOn()) \

Tracer::trace( \

{ \

__FILE__, __LINE__,traceComponent,traceLevel,traceString); \

PEGASUS_ASSERT(level != Tracer::LEVEL1); \

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

{ \

Tracer::traceCString(PEGASUS_FILE_LINE_COMMA \

comp, \

(const char*) (string).getCString()); \

} \

while (0)

#endif

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

Legend:

Removed from v.1.21
changed lines
	Added in v.1.31

No CVS admin address has been configured