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.34 and 1.50

version 1.34, 2008/05/12 09:17:34

version 1.50, 2011/01/25 12:10:21

Line 1

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

//%LICENSE////////////////////////////////////////////////////////////////

// Licensed to The Open Group (TOG) under one or more contributor license

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

// agreements. Refer to the OpenPegasusNOTICE.txt file distributed with

// this work for additional information regarding copyright ownership.

// IBM Corp.; EMC Corporation, The Open Group.

// Each contributor licenses this file to you under the OpenPegasus Open

// Source License; you may not use this file except in compliance with the

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

// License.

// EMC Corporation; VERITAS Software 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"),

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

// to deal in the Software without restriction, including without limitation

// the rights to use, copy, modify, merge, publish, distribute, sublicense,

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

// and/or sell copies of the Software, and to permit persons to whom the

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

// Software is furnished to do so, subject to the following conditions:

// deal in the Software without restriction, including without limitation the

// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or

// The above copyright notice and this permission notice shall be included

// sell copies of the Software, and to permit persons to whom the Software is

// in all copies or substantial portions of the Software.

// furnished to do so, subject to the following conditions:

// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS

// THE ABOVE COPYRIGHT NOTICE AND THIS PERMISSION NOTICE SHALL BE INCLUDED IN

// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF

// ALL COPIES OR SUBSTANTIAL PORTIONS OF THE SOFTWARE. THE SOFTWARE IS PROVIDED

// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.

// "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT

// IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY

// LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR

// CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,

// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT

// TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE

// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN

// SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

// ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION

// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

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

//////////////////////////////////////////////////////////////////////////

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

Line 39

Line 37

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

TRC_XML_IO,

TRC_HTTP,

TRC_REPOSITORY,

TRC_DISPATCHER,

TRC_OS_ABSTRACTION,

TRC_CONFIG,

TRC_IND_HANDLER,

TRC_AUTHENTICATION,

TRC_AUTHORIZATION,

TRC_USER_MANAGER,

TRC_SHUTDOWN,

TRC_SERVER,

TRC_INDICATION_SERVICE,

TRC_MESSAGEQUEUESERVICE,

TRC_PROVIDERMANAGER,

TRC_OBJECTRESOLUTION,

TRC_WQL,

TRC_CQL,

TRC_THREAD,

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,

TRC_WMI_MAPPER_CONSUMER

};

/** Token used for tracing functions.

struct TracerToken

{

Uint32 component;

TraceComponentId component;

const char* method;

};

Line 60

Line 107

{

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

Line 84

Line 147

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 158

@param cimException the CIMException to be traced.

static void traceCIMException(

const Uint32 traceComponent,

const TraceComponentId traceComponent,

const Uint32 level,

const CIMException& cimException);

/** Formats the message given in data as hex dump if binary is true

@param data Message to be formatted

@param binary flag indicating if message is binary or not

static SharedArrayPtr<char> traceFormatChars(

const Buffer& data,

bool binary);

/** Gets an HTTP request message.

Given a binary HTTP request message(application/x-openpegasus

this method returns the request message formatted in hex dump format

and returns.

Given an HTTP request message, this method checks if the

message contains a "Basic" authorization header.

Line 138

Line 213

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 250

TracerToken& token,

const char* file,

size_t line,

Uint32 component,

TraceComponentId traceComponent,

const char* method);

/** Traces method exit.

Line 186

Line 287

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 311

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

Line 341

static const Uint32 _NUM_COMPONENTS;

static const Uint32 _STRLEN_MAX_UNSIGNED_INT;

static const Uint32 _STRLEN_MAX_PID_TID;

AutoArrayPtr<Boolean> _traceComponentMask;

static Uint64 _traceComponentMask;

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

static Uint32 _traceLevelMask;

Boolean _componentsAreSet;

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[];

// Function formats size bytes of binary data given in data in a nicely

// readable hex format and writes the output to targetBuffer

// Return value: Pointer to one byte behind last position that was written

static char* _formatHexDump(

char* targetBuffer,

const char* data,Uint32 size);

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

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

// @param traceComponent component being traced

Line 249

Line 381

static void _trace(

const char* fileName,

const Uint32 lineNum,

const Uint32 traceComponent,

const TraceComponentId traceComponent,

const char* fmt,

va_list argList);

Line 260

Line 392

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

Line 400

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

Line 410

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

Line 423

static void _traceMethod(

const char* fileName,

const Uint32 lineNum,

const Uint32 traceComponent,

const TraceComponentId traceComponent,

const char* methodEntryExit,

const char* method);

Line 309

Line 441

friend class TraceCallFrame;

friend class TracePropertyOwner;

friend class TraceMemoryHandler;

friend class TraceFileHandler;

};

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

Line 323

Line 457

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 361

Line 495

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

Line 541

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

Line 569

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

{ \

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 461

Line 607

PEGASUS_FORMAT(4, 5)

inline void invoke(

const Uint32 component,

const TraceComponentId component,

const Uint32 level,

const char* format,

...)

Legend:

Removed from v.1.34
changed lines
	Added in v.1.50

No CVS admin address has been configured