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.33 and 1.44

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

version 1.44, 2008/10/24 06:03:19

Line 39

#include <Pegasus/Common/System.h>

#include <Pegasus/Common/Logger.h>

#include <Pegasus/Common/InternalException.h>

#include <Pegasus/Common/TraceComponents.h>

#include <Pegasus/Common/TraceHandler.h>

#include <Pegasus/Common/TraceFileHandler.h>

#include <Pegasus/Common/Linkage.h>

#include <Pegasus/Common/SharedPtr.h>

PEGASUS_NAMESPACE_BEGIN

/**

Trace component identifiers. This list must be kept in sync with the

TRACE_COMPONENT_LIST in Tracer.cpp.

The tracer uses the _traceComponentMask 64bit field to mask

the user configured components.

Please ensure that no more than 64 Trace Component ID's are specified.

enum TraceComponentId

{

TRC_XML_PARSER,

TRC_XML_WRITER,

TRC_XML_READER,

TRC_XML_IO,

TRC_HTTP,

TRC_CIM_DATA,

TRC_REPOSITORY,

TRC_DISPATCHER,

TRC_OS_ABSTRACTION,

TRC_CONFIG,

TRC_IND_HANDLER,

TRC_AUTHENTICATION,

TRC_AUTHORIZATION,

TRC_USER_MANAGER,

TRC_REGISTRATION,

TRC_SHUTDOWN,

TRC_SERVER,

TRC_INDICATION_SERVICE,

TRC_INDICATION_SERVICE_INTERNAL,

TRC_MESSAGEQUEUESERVICE,

TRC_PROVIDERMANAGER,

TRC_OBJECTRESOLUTION,

TRC_WQL,

TRC_CQL,

TRC_THREAD,

TRC_IPC,

TRC_IND_HANDLE,

TRC_EXP_REQUEST_DISP,

TRC_SSL,

TRC_CONTROLPROVIDER,

TRC_CIMOM_HANDLE,

TRC_L10N,

TRC_EXPORT_CLIENT,

TRC_LISTENER,

TRC_DISCARDED_DATA,

TRC_PROVIDERAGENT,

TRC_IND_FORMATTER,

TRC_STATISTICAL_DATA,

TRC_CMPIPROVIDER,

TRC_INDICATION_GENERATION,

TRC_INDICATION_RECEIPT,

TRC_CMPIPROVIDERINTERFACE,

TRC_WSMSERVER,

TRC_LOGMSG

};

/** Token used for tracing functions.

struct TracerToken

{

Uint32 component;

TraceComponentId component;

const char* method;

};

Line 60

Line 115

{

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,

TRACE_FACILITY_MEMORY = 2

};

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

Line 155

static void traceCString(

const char* fileName,

const Uint32 lineNum,

const Uint32 traceComponent,

const TraceComponentId traceComponent,

const char* cstring);

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

Line 95

Line 166

@param cimException the CIMException to be traced.

static void traceCIMException(

const Uint32 traceComponent,

const TraceComponentId traceComponent,

const Uint32 level,

const CIMException& cimException);

Line 138

Line 209

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

TRACE_FACILITY_MEMORY - if trace facility is memory tracing

static Uint32 getTraceFacility();

/** Set buffer size to be used for the memory tracing facility

@param bufferSize buffer size in Kbyte to be used for memory tracing

@return true if function was successfully.

static Boolean setTraceMemoryBufferSize(Uint32 bufferSize);

/** Flushes the trace buffer to traceFilePath. This method will only

have an effect when traceFacility=Memory.

static void flushTrace();

/** Traces method entry.

@param token TracerToken

@param fileName filename of the trace originator

Line 149

Line 246

TracerToken& token,

const char* file,

size_t line,

Uint32 component,

TraceComponentId traceComponent,

const char* method);

/** Traces method exit.

Line 186

Line 283

const String& traceComponents,

String& invalidComponents);

/** Specify the name of the module being traced. If non-empty, this

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

/** Signals the trace to be running OOP and provides the file name

extension of the trace file. 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.

@param oopTraceFileExtension Trace file extension.

static void setModuleName(const String& moduleName);

static void setOOPTraceFileExtension(const String& oopTraceFileExtension);

/**

Line 202

Line 307

// @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 TraceComponentId traceComponent,

const Uint32 level);

const Uint32 traceLevel)

{

return ((traceLevel & _traceLevelMask) &&

(_traceComponentMask & ((Uint64)1 << traceComponent)));

}

private:

Line 214

Line 323

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 Uint64 _traceComponentMask;

static const Boolean _FAILURE;

static Uint32 _traceLevelMask;

AutoArrayPtr<Boolean> _traceComponentMask;

Uint32 _traceLevelMask;

AutoPtr<TraceFileHandler> _traceHandler;

String _moduleName;

static Tracer* _tracerInstance;

Uint32 _traceMemoryBufferSize;

Uint32 _traceFacility;

Boolean _runningOOP;

TraceHandler* _traceHandler;

String _traceFile;

String _oopTraceFileExtension;

// Message Strings for function Entry and Exit

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

void _setTraceHandler( Uint32 traceFacility );

// Validates if the given file path if it is eligible for writing traces.

// @param fileName a file intended to be used to write traces

static Boolean _isValidTraceFile(String fileName);

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

// line number as one of the parameters.

Line 242

Line 370

static void _trace(

const char* fileName,

const Uint32 lineNum,

const Uint32 traceComponent,

const TraceComponentId traceComponent,

const char* fmt,

va_list argList);

Line 253

Line 381

// @param CIMException the CIMException to be traced.

static void _traceCIMException(

const Uint32 traceComponent,

const TraceComponentId traceComponent,

const CIMException& cimException);

// Called by all the trace interfaces to log message

Line 261

Line 389

// @param traceComponent component being traced

// @param cstring the string to be traced

static void _traceCString(

const Uint32 traceComponent,

const TraceComponentId traceComponent,

const char* message,

const char* cstring);

Line 271

Line 399

// @param *fmt printf style format string

// @param argList variable argument list

static void _trace(

const Uint32 traceComponent,

const TraceComponentId traceComponent,

const char* message,

const char* fmt,

va_list argList);

Line 284

Line 412

static void _traceMethod(

const char* fileName,

const Uint32 lineNum,

const Uint32 traceComponent,

const TraceComponentId traceComponent,

const char* methodEntryExit,

const char* method);

Line 301

Line 429

static Tracer* _getInstance();

friend class TraceCallFrame;

friend class TracePropertyOwner;

friend class TraceMemoryHandler;

friend class TraceFileHandler;

};

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

Line 315

Line 446

inline void Tracer::traceCString(

const char* fileName,

const Uint32 lineNum,

const Uint32 traceComponent,

const TraceComponentId traceComponent,

const char* cstring)

{

// empty function

}

inline void Tracer::traceCIMException(

const Uint32 traceComponent,

const TraceComponentId traceComponent,

const Uint32 level,

const CIMException& cimException)

{

Line 353

Line 484

// empty function

}

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

{

// empty function

return 0;

}

inline Uint32 Tracer::getTraceFacility()

{

// empty function

return 0;

}

inline Boolean Tracer::setTraceMemoryBufferSize(Uint32 bufferSize)

{

// empty function

return true;

}

inline void Tracer::flushTrace()

{

// empty function

return;

}

#endif /* PEGASUS_REMOVE_TRACE */

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

Line 375

Line 530

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

Line 399

Line 558

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

{ \

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.

Line 425

Line 567

{ \

if (Tracer::isTraceOn()) \

{ \

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

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

{ \

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

Line 455

Line 596

PEGASUS_FORMAT(4, 5)

inline void invoke(

const Uint32 component,

const TraceComponentId component,

const Uint32 level,

const char* format,

...)

Legend:

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

No CVS admin address has been configured