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

Return to Tracer.cpp CVS log

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

Diff for /pegasus/src/Pegasus/Common/Tracer.cpp between version 1.38 and 1.52

version 1.38, 2006/08/21 15:31:03

version 1.52, 2008/09/02 17:33:37

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)

// Josephine Eskaline Joyce, IBM (jojustin@in.ibm.com) for Bug#2498

// Sean Keenan, Hewlett-Packard Company (sean.keenan@hp.com)

// David Dillard, Symantec Corp. (david_dillard@symantec.com)

// Aruran, IBM (ashanmug@in.ibm.com) for Bug# 4547

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

#include <Pegasus/Common/Config.h>

#include <Pegasus/Common/Tracer.h>

#include <Pegasus/Common/TraceFileHandler.h>

#include <Pegasus/Common/TraceLogHandler.h>

#include <Pegasus/Common/TraceMemoryHandler.h>

#include <Pegasus/Common/Thread.h>

#include <Pegasus/Common/System.h>

#include <Pegasus/Common/HTTPMessage.h>

#include <Pegasus/Common/StringConversion.h>

PEGASUS_USING_STD;

PEGASUS_NAMESPACE_BEGIN

// Defines the value values for trace facilities

// Keep the TRACE_FACILITY_LIST in sync with the TRACE_FACILITY_INDEX,

// so that the index matches the according string in the list.

char const* Tracer::TRACE_FACILITY_LIST[] =

{

"File",

"Log",

"Memory",

};

// Set the trace levels

// These levels will be compared against a trace level mask to determine

// if a specific trace level is enabled

const Uint32 Tracer::LEVEL0 = 0;

const Uint32 Tracer::LEVEL1 = (1 << 0);

const Uint32 Tracer::LEVEL2 = (1 << 1);

const Uint32 Tracer::LEVEL3 = (1 << 2);

const Uint32 Tracer::LEVEL4 = (1 << 3);

const Uint32 Tracer::LEVEL5 = (1 << 4);

// Set the return codes

const Boolean Tracer::_SUCCESS = 1;

const Boolean Tracer::_FAILURE = 0;

// Set the Enter and Exit messages

const char Tracer::_METHOD_ENTER_MSG[] = "Entering method";

const char Tracer::_METHOD_EXIT_MSG[] = "Exiting method";

// Set Log messages

const char Tracer::_LOG_MSG[] = "LEVEL1 may only be used with trace macros PEG_METHOD_ENTER/PEG_METHOD_EXIT.";

// Initialize singleton instance of Tracer

Tracer* Tracer::_tracerInstance = 0;

Line 84

Line 87

const Uint32 Tracer::_STRLEN_MAX_UNSIGNED_INT = 21;

// Set the max PID and Thread ID Length

const Uint32 Tracer::_STRLEN_MAX_PID_TID = 20;

const Uint32 Tracer::_STRLEN_MAX_PID_TID = 21;

// Initialize public indicator of trace state

Boolean Tracer::_traceOn = false;

Line 96

Line 99

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

Tracer::Tracer()

: _traceComponentMask(new Boolean[_NUM_COMPONENTS]),

_traceMemoryBufferSize(PEGASUS_TRC_DEFAULT_BUFFER_SIZE_KB),

_traceFacility(TRACE_FACILITY_FILE),

_traceLevelMask(0),

_traceHandler(new TraceFileHandler())

_traceHandler(0)

{

// Instantiate trace handler according to configured facility

_setTraceHandler(_traceFacility);

// Initialize ComponentMask array to false

for (Uint32 index=0;index < _NUM_COMPONENTS;

(_traceComponentMask.get())[index++]=false);

// NO componets are set

_componentsAreSet=false;

}

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

Line 109

Line 120

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

Tracer::~Tracer()

{

delete _traceHandler;

delete _tracerInstance;

}

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

//Traces the given message

//Factory function for the trace handler instances.

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

void Tracer::_trace(

void Tracer::_setTraceHandler( Uint32 traceFacility )

const Uint32 traceComponent,

const Uint32 traceLevel,

const char* fmt,

va_list argList)

{

if ( traceLevel == LEVEL1 )

{

trace( traceComponent, Tracer::LEVEL4, "%s", _LOG_MSG );

}

else

{

if (_isTraceEnabled(traceComponent,traceLevel))

TraceHandler * oldTrcHandler = _traceHandler;

switch(traceFacility)

{

_trace(traceComponent,"",fmt,argList);

case TRACE_FACILITY_LOG:

}

_traceFacility = TRACE_FACILITY_LOG;

_traceHandler = new TraceLogHandler();

break;

case TRACE_FACILITY_MEMORY:

_traceFacility = TRACE_FACILITY_MEMORY;

_traceHandler = new TraceMemoryHandler(_traceMemoryBufferSize);

break;

case TRACE_FACILITY_FILE:

default:

_traceFacility = TRACE_FACILITY_FILE;

_traceHandler = new TraceFileHandler();

}

delete oldTrcHandler;

}

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

Line 142

Line 160

const char* fileName,

const Uint32 lineNum,

const Uint32 traceComponent,

const Uint32 traceLevel,

const char* fmt,

va_list argList)

{

char* message;

if ( traceLevel == LEVEL1 )

{

trace( traceComponent, Tracer::LEVEL4, "%s", _LOG_MSG );

}

else

{

if (_isTraceEnabled(traceComponent,traceLevel))

{

// Allocate memory for the message string

// Needs to be updated if additional info is added

Line 164

Line 172

_STRLEN_MAX_UNSIGNED_INT + (_STRLEN_MAX_PID_TID * 2) + 8 ];

sprintf(

message,

"[%d:%s:%s:%u]: ",

"[%u:%s:%s:%u]: ",

System::getPID(),

Threads::id().buffer,

fileName,

Line 173

Line 181

_trace(traceComponent,message,fmt,argList);

delete []message;

}

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

//Traces the given buffer

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

void Tracer::_traceBuffer(

const Uint32 traceComponent,

const Uint32 traceLevel,

const char* data,

const Uint32 size)

{

if ( traceLevel == LEVEL1 )

{

trace( traceComponent, Tracer::LEVEL4, "%s", _LOG_MSG );

}

else

{

if (_isTraceEnabled(traceComponent,traceLevel))

{

char* tmpBuf = new char[size+1];

strncpy( tmpBuf, data, size );

tmpBuf[size] = '\0';

trace(traceComponent,traceLevel,"%s",tmpBuf);

delete []tmpBuf;

}

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

//Traces the given buffer - Overloaded for including FileName and Line number

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

void Tracer::_traceBuffer(

const char* fileName,

const Uint32 lineNum,

const Uint32 traceComponent,

const Uint32 traceLevel,

const char* data,

const Uint32 size)

{

if ( traceLevel == LEVEL1 )

{

trace( traceComponent, Tracer::LEVEL4, "%s", _LOG_MSG );

}

else

{

if ( _isTraceEnabled( traceComponent, traceLevel ) )

{

char* tmpBuf = new char[size+1];

strncpy( tmpBuf, data, size );

tmpBuf[size] = '\0';

trace(fileName,lineNum,traceComponent,traceLevel,"%s",tmpBuf);

delete []tmpBuf;

}

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

//Traces the given string

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

void Tracer::_traceString(

const Uint32 traceComponent,

const Uint32 traceLevel,

const String& traceString)

{

if ( traceLevel == LEVEL1 )

{

trace( traceComponent, Tracer::LEVEL4, "%s", _LOG_MSG );

}

else

{

if (_isTraceEnabled(traceComponent,traceLevel))

{

trace(traceComponent,traceLevel,"%s",

(const char *)traceString.getCString());

}

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

//Traces the given string - Overloaded to include the fileName and line number

//of trace origin.

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

void Tracer::_traceString(

const char* fileName,

const Uint32 lineNum,

const Uint32 traceComponent,

const Uint32 traceLevel,

const String& traceString)

{

if ( traceLevel == LEVEL1 )

{

trace( traceComponent, Tracer::LEVEL4, "%s", _LOG_MSG );

}

else

{

if ( _isTraceEnabled( traceComponent, traceLevel ) )

{

trace(fileName,lineNum,traceComponent,traceLevel,"%s",

(const char *)traceString.getCString());

}

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

//Traces the message in the given CIMException object.

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

void Tracer::_traceCIMException(

const Uint32 traceComponent,

const Uint32 traceLevel,

const CIMException& cimException)

CIMException cimException)

{

if ( traceLevel == LEVEL1 )

{

trace( traceComponent, Tracer::LEVEL4, "%s", _LOG_MSG );

}

else

{

if ( _isTraceEnabled( traceComponent, traceLevel ) )

{

// get the CIMException trace message string

String traceMsg =

CString traceMsg =

TraceableCIMException(cimException).getTraceDescription();

TraceableCIMException(cimException).getTraceDescription().getCString();

// trace the string

_traceString(traceComponent, traceLevel, traceMsg);

_traceCString(traceComponent, "", (const char*) traceMsg);

}

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

SharedArrayPtr<char> Tracer::getHTTPRequestMessage(

//Traces method entry

const Buffer& requestMessage)

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

void Tracer::_traceEnter(

const char* fileName,

const Uint32 lineNum,

const Uint32 traceComponent,

const char* fmt,

...)

{

va_list argList;

char* message;

if (_isTraceEnabled(traceComponent,LEVEL1))

{

const Uint32 requestSize = requestMessage.size();

va_start(argList,fmt);

// Make a copy of the request message.

SharedArrayPtr<char>

requestBuf(new char [requestSize + 1]);

strncpy(requestBuf.get(), requestMessage.getData(), requestSize);

requestBuf.get()[requestSize] = 0;

// Allocate memory for the message string

// Check if requestBuffer contains a Basic authorization header.

// Needs to be updated if additional info is added

// If true, suppress the user/passwd info in the request buffer.

message = new char[ strlen(fileName) +

char* sep;

_STRLEN_MAX_UNSIGNED_INT + (_STRLEN_MAX_PID_TID * 2) + 8 ];

const char* line = requestBuf.get();

sprintf(

while ((sep = HTTPMessage::findSeparator(

message,

line, (Uint32)(requestSize - (line - requestBuf.get())))) &&

"[%d:%s:%s:%u]: ",

(line != sep))

System::getPID(),

{

Threads::id().buffer,

if (HTTPMessage::expectHeaderToken(line, "Authorization") &&

fileName,

HTTPMessage::expectHeaderToken(line, ":") &&

lineNum);

HTTPMessage::expectHeaderToken(line, "Basic"))

{

// Suppress the user/passwd info

HTTPMessage::skipHeaderWhitespace(line);

for ( char* userpass = (char*)line ;

userpass < sep;

*userpass = 'X', userpass++);

_trace(traceComponent,message,fmt,argList);

break;

}

va_end(argList);

line = sep + ((*sep == '\r') ? 2 : 1);

delete []message;

}

return requestBuf;

}

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

//Traces method exit

//Traces method entry and exit

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

void Tracer::_traceExit(

void Tracer::_traceMethod(

const char* fileName,

const Uint32 lineNum,

const Uint32 traceComponent,

const char* fmt

const char* methodEntryExit,

...)

const char* method)

{

va_list argList;

char* message;

if (_isTraceEnabled(traceComponent,LEVEL1))

{

va_start(argList,fmt);

// Allocate memory for the message string

// Needs to be updated if additional info is added

// assume Method entry/exit string 15 characters long

// +1 space character

message = new char[ strlen(fileName) +

_STRLEN_MAX_UNSIGNED_INT + (_STRLEN_MAX_PID_TID * 2) + 8 ];

_STRLEN_MAX_UNSIGNED_INT + (_STRLEN_MAX_PID_TID * 2) + 8

+ 16];

sprintf(

message,

"[%d:%s:%s:%u]: ",

"[%u:%s:%s:%u]: %s ",

System::getPID(),

Threads::id().buffer,

fileName,

lineNum);

lineNum,

methodEntryExit);

_trace(traceComponent,message,fmt,argList);

_traceCString(traceComponent, message, method);

va_end(argList);

delete []message;

}

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

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

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

Boolean Tracer::_isTraceEnabled(const Uint32 traceComponent,

Boolean Tracer::isTraceEnabled(

const Uint32 traceComponent,

const Uint32 traceLevel)

{

Tracer* instance = _getInstance();

Line 401

Line 291

}

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

//Called by all trace interfaces to log message to trace file

//Called by all trace interfaces with variable arguments

//to log message to trace file

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

void Tracer::_trace(

const Uint32 traceComponent,

Line 410

Line 301

va_list argList)

{

char* msgHeader;

Uint32 msgLen;

Uint32 usec,sec;

// Get the current system time and prepend to message

String currentTime = System::getCurrentASCIITime();

System::getCurrentTimeUsec(sec,usec);

CString timeStamp = currentTime.getCString();

// Allocate messageHeader.

// Needs to be updated if additional info is added

// Construct the message header

// The message header is in the following format

// timestamp: <component name> [file name:line number]

// Format string length calculation:

// 11(sec)+ 2('s-')+11(usec)+4('us: ')+1(' ')+1(\0) = 30

if (*message != '\0')

{

msgHeader = new char [strlen(message) +

strlen(TRACE_COMPONENT_LIST[traceComponent]) + 30];

msgLen = sprintf(msgHeader, "%us-%uus: %s %s", sec, usec,

TRACE_COMPONENT_LIST[traceComponent], message);

}

else

{

// Allocate messageHeader.

// Needs to be updated if additional info is added

// Format string length calculation:

// 11(sec)+2('s-')+11(usec)+4('us: ')+

// +2(' [')+1(':')+3(']: ')+1(\0) = 35

msgHeader = new char[2 * _STRLEN_MAX_PID_TID +

strlen(TRACE_COMPONENT_LIST[traceComponent]) + 35];

msgLen = sprintf(msgHeader, "%us-%uus: %s [%u:%s]: ", sec, usec,

TRACE_COMPONENT_LIST[traceComponent],

System::getPID(), Threads::id().buffer);

}

// Call trace file handler to write message

_getInstance()->_traceHandler->handleMessage(msgHeader,msgLen,fmt,argList);

delete [] msgHeader;

}

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

//Called by all trace interfaces using a character string without format string

//to log message to trace file

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

void Tracer::_traceCString(

const Uint32 traceComponent,

const char* message,

const char* cstring)

{

char* completeMessage;

Uint32 msgLen;

Uint32 usec,sec;

// Get the current system time and prepend to message

System::getCurrentTimeUsec(sec,usec);

// Allocate completeMessage.

// Needs to be updated if additional info is added

// Construct the message header

// The message header is in the following format

// timestamp: <component name> [file name:line number]

// Format string length calculation:

// 11(sec)+ 2('s-')+11(usec)+4('us: ')+1(' ')+1(\0) = 30

if (*message != '\0')

{

// << Wed Jul 16 10:58:40 2003 mdd >> _STRLEN_MAX_PID_TID is not used in this format string

completeMessage = new char [strlen(message) +

msgHeader = new char [strlen(message)

strlen(TRACE_COMPONENT_LIST[traceComponent]) +

+ strlen(TRACE_COMPONENT_LIST[traceComponent])

strlen(cstring) + 30];

+ strlen(timeStamp) + _STRLEN_MAX_PID_TID + 5];

sprintf(msgHeader,"%s: %s %s",(const char*)timeStamp,

msgLen = sprintf(completeMessage, "%us-%uus: %s %s%s", sec, usec,

TRACE_COMPONENT_LIST[traceComponent] ,message);

TRACE_COMPONENT_LIST[traceComponent], message, cstring);

//delete [] msgHeader;

}

else

{

// Since the message is blank form a string using the pid and tid

// Since the message is blank, form a string using the pid and tid

char* tmpBuffer;

Line 447

Line 396

// Allocate messageHeader.

// Needs to be updated if additional info is added

tmpBuffer = new char[_STRLEN_MAX_PID_TID + 6];

// Format string length calculation:

sprintf(tmpBuffer, "[%u:%s]: ", System::getPID(), Threads::id().buffer);

// 11(sec)+2('s-')+11(usec)+4('us: ')+

msgHeader = new char [ strlen(timeStamp) + strlen(TRACE_COMPONENT_LIST[traceComponent]) +

// +2(' [')+1(':')+3(']: ')+1(\0) = 35

strlen(tmpBuffer) + 1 + 5 ];

completeMessage = new char[2 * _STRLEN_MAX_PID_TID +

strlen(TRACE_COMPONENT_LIST[traceComponent]) +

sprintf(msgHeader,"%s: %s %s ",(const char*)timeStamp,

strlen(cstring) +35];

TRACE_COMPONENT_LIST[traceComponent] ,tmpBuffer );

delete []tmpBuffer;

msgLen = sprintf(completeMessage, "%us-%uus: %s [%u:%s] %s", sec, usec,

//delete [] msgHeader;

TRACE_COMPONENT_LIST[traceComponent],

System::getPID(), Threads::id().buffer,

cstring);

}

// Call trace file handler to write message

_getInstance()->_traceHandler->handleMessage(msgHeader,fmt,argList);

_getInstance()->_traceHandler->handleMessage(completeMessage,msgLen);

delete [] msgHeader;

delete [] completeMessage;

}

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

//Validate the trace file

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

Line 473

Line 424

String moduleName = _getInstance()->_moduleName;

if (moduleName == String::EMPTY)

{

return (_getInstance()->_traceHandler->isValidFilePath(filePath));

return

_getInstance()->_traceHandler->isValidMessageDestination(filePath);

}

else

{

String extendedFilePath = String(filePath) + "." + moduleName;

return (_getInstance()->_traceHandler->isValidFilePath(

return _getInstance()->_traceHandler->isValidMessageDestination(

extendedFilePath.getCString()));

extendedFilePath.getCString());

}

Line 493

Line 445

}

Boolean Tracer::isValidComponents(

const String& traceComponents, String& invalidComponents)

const String& traceComponents,

String& invalidComponents)

{

// Validate the trace components and modify the traceComponents argument

// to reflect the invalid components

Uint32 position=0;

Uint32 index=0;

String componentName = String::EMPTY;

String componentName;

String componentStr = String::EMPTY;

String componentStr;

Boolean validComponent=false;

Boolean retCode=true;

Line 513

Line 466

// Check if ALL is specified

if (String::equalNoCase(componentStr,"ALL"))

{

return _SUCCESS;

return true;

}

// Append _COMPONENT_SEPARATOR to the end of the traceComponents

Line 560

Line 513

else

{

// trace components is empty, it is a valid value so return true

return _SUCCESS;

return true;

}

if ( invalidComponents != String::EMPTY )

{

retCode = false;

Line 575

Line 529

}

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

//Validate the trace facility

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

Boolean Tracer::isValidTraceFacility(const String& traceFacility)

{

Boolean retCode = false;

if (traceFacility.size() != 0)

{

Uint32 index = 0;

while (TRACE_FACILITY_LIST[index] != 0 )

{

if (String::equalNoCase(traceFacility,TRACE_FACILITY_LIST[index]))

{

retCode = true;

break;

}

index++;

}

return retCode;

}

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

//Set the name of the module being traced

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

void Tracer::setModuleName(const String& moduleName)

Line 614

Line 592

String moduleName = _getInstance()->_moduleName;

if (moduleName == String::EMPTY)

{

return (_getInstance()->_traceHandler->setFileName(traceFile));

return _getInstance()->_traceHandler->setMessageDestination(traceFile);

}

else

{

String extendedTraceFile = String(traceFile) + "." + moduleName;

return (_getInstance()->_traceHandler->setFileName(

return _getInstance()->_traceHandler->setMessageDestination(

extendedTraceFile.getCString()));

extendedTraceFile.getCString());

}

Line 633

Line 611

switch (traceLevel)

{

case LEVEL0:

_getInstance()->_traceLevelMask = 0x00;

break;

case LEVEL1:

_getInstance()->_traceLevelMask = 0x01;

break;

Line 649

Line 631

_getInstance()->_traceLevelMask = 0x0F;

break;

case LEVEL5:

_getInstance()->_traceLevelMask = 0x1F;

break;

default:

_getInstance()->_traceLevelMask = 0;

_getInstance()->_traceLevelMask = 0x00;

retCode = 1;

}

if (_getInstance()->_componentsAreSet &&

_getInstance()->_traceLevelMask )

{

_traceOn = true;

}

else

{

_traceOn = false;

}

return retCode;

}

Line 661

Line 658

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

void Tracer::setTraceComponents(const String& traceComponents)

{

Uint32 position = 0;

Tracer* instance = _getInstance();

Uint32 index = 0;

String componentName = String::EMPTY;

String componentStr = traceComponents;

String invalidComponents = String::EMPTY;

if (componentStr != String::EMPTY)

{

// Check if ALL is specified

if (String::equalNoCase(componentStr,"ALL"))

if (String::equalNoCase(traceComponents,"ALL"))

{

for (index=0; index < _NUM_COMPONENTS;

for (Uint32 index = 0; index < _NUM_COMPONENTS; index++)

(_getInstance()->_traceComponentMask.get())[index++] = true);

{

_traceOn = true;

(instance->_traceComponentMask.get())[index] = true;

}

instance->_componentsAreSet=true;

// If tracing isn't turned off by a traceLevel of zero, let's

// turn on the flag that activates tracing.

_traceOn = (instance->_traceLevelMask != LEVEL0);

return ;

}

// initialise ComponentMask array to False

// initialize ComponentMask array to False

for (index = 0;index < _NUM_COMPONENTS;

for (Uint32 index = 0; index < _NUM_COMPONENTS; index++)

(_getInstance()->_traceComponentMask.get())[index++] = false);

{

(instance->_traceComponentMask.get())[index] = false;

}

_traceOn = false;

instance->_componentsAreSet=false;

if (traceComponents != String::EMPTY)

{

Uint32 index = 0;

Uint32 position = 0;

String componentName;

String componentStr = traceComponents;

// Append _COMPONENT_SEPARATOR to the end of the traceComponents

componentStr.append(_COMPONENT_SEPARATOR);

Line 700

Line 710

if (String::equalNoCase(

componentName,TRACE_COMPONENT_LIST[index]))

{

(_getInstance()->_traceComponentMask.get())[index]=true;

(instance->_traceComponentMask.get())[index] = true;

_traceOn = true;

instance->_componentsAreSet=true;

// Found component, break from the loop

break;

Line 715

Line 726

// Remove the searched componentname from the traceComponents

componentStr.remove(0,position+1);

}

// If one of the components was set for tracing and the traceLevel

// is not zero, then turn on tracing.

_traceOn = (instance->_componentsAreSet &&

(instance->_traceLevelMask != LEVEL0));

}

else

{

// initialise ComponentMask array to False

for (Uint32 index = 0;index < _NUM_COMPONENTS;

(_getInstance()->_traceComponentMask.get())[index++] = false);

_traceOn = 0;

}

return ;

}

void Tracer::traceEnter(TracerToken& token, Uint32 traceComponent, const char* method)

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

// Set the trace facility to be used

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

Uint32 Tracer::setTraceFacility(const String& traceFacility)

{

if (_traceOn)

Uint32 retCode = 0;

Tracer* instance = _getInstance();

if (traceFacility.size() != 0)

{

token.component = traceComponent;

Uint32 index = 0;

token.method = method;

while (TRACE_FACILITY_LIST[index] != 0 )

{

if (String::equalNoCase( traceFacility,TRACE_FACILITY_LIST[index]))

{

if (index != instance->_traceFacility)

{

instance->_setTraceHandler(index);

}

retCode = 1;

break;

}

index++;

}

//Tracer::traceEnter("unknown", 0, component, method);

return retCode;

_traceEnter( "unknown", 0, traceComponent, "%s %s",

_METHOD_ENTER_MSG, method);

}

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

// Get the trace facility in use

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

Uint32 Tracer::getTraceFacility()

{

return _getInstance()->_traceFacility;

}

void Tracer::traceExit(TracerToken& token)

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

// Set the size of the memory trace buffer

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

Boolean Tracer::setTraceMemoryBufferSize(Uint32 bufferSize)

{

if (_traceOn)

Tracer* instance = _getInstance();

instance->_traceMemoryBufferSize = bufferSize;

// KS Tracer::traceExit("unknown", 0, token.component, token.method);

// If we decide to dynamically change the trace buffer size,

_traceExit( "unknown",0, token.component, "%s %s",

// this is where it needs to be implemented.

_METHOD_EXIT_MSG, token.method);

return true;

}

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

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

// have an effect when traceFacility=Memory.

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

void Tracer::flushTrace()

{

_getInstance()->_traceHandler->flushTrace();

return;

}

void Tracer::traceEnter(

TracerToken& token,

const char* file,

Line 755

Line 804

Uint32 traceComponent,

const char* method)

{

if (_traceOn)

{

token.component = traceComponent;

token.method = method;

//Tracer::traceEnter(file, line, component, method);

if (isTraceEnabled(traceComponent, LEVEL5))

_traceEnter( file, line, traceComponent, "%s %s",

{

_traceMethod(

file, (Uint32)line, traceComponent,

_METHOD_ENTER_MSG, method);

}

Line 771

Line 820

const char* file,

size_t line)

{

if (_traceOn)

if (isTraceEnabled(token.component, LEVEL5) && token.method)

//Tracer::traceExit(file, line, token.component, token.method);

_traceMethod(

_traceExit( file, line, token.component, "%s %s",

file, (Uint32)line, token.component,

_METHOD_EXIT_MSG, token.method);

}

void Tracer::traceBuffer(

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

const Uint32 traceComponent,

//Traces the given string - Overloaded to include the fileName and line number

const Uint32 traceLevel,

//of trace origin.

const char* data,

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

const Uint32 size)

void Tracer::traceCString(

{

if (_traceOn)

_traceBuffer( traceComponent, traceLevel, data, size );

}

void Tracer::traceBuffer(

const char* fileName,

const Uint32 lineNum,

const Uint32 traceComponent,

const Uint32 traceLevel,

const char* cstring)

const char* data,

const Uint32 size)

{

if (_traceOn)

char* message;

{

_traceBuffer( fileName, lineNum,

traceComponent, traceLevel, data, size );

}

void Tracer::trace(

Uint32 msgLen;

const Uint32 traceComponent,

Uint32 usec,sec;

const Uint32 traceLevel,

const char *fmt,

...)

{

if (_traceOn)

{

va_list argList;

va_start(argList,fmt);

// Get the current system time

_trace(traceComponent,traceLevel,fmt,argList);

System::getCurrentTimeUsec(sec,usec);

va_end(argList);

}

void Tracer::trace(

const char* fileName,

// Allocate memory for the message string

const Uint32 lineNum,

// Needs to be updated if additional info is added

const Uint32 traceComponent,

const Uint32 traceLevel,

message = new char [strlen(fileName) +

const char* fmt,

_STRLEN_MAX_UNSIGNED_INT + (_STRLEN_MAX_PID_TID * 2) + 8 +

...)

strlen(TRACE_COMPONENT_LIST[traceComponent]) +

{

strlen(cstring) + 30];

if (_traceOn)

{

msgLen = sprintf(message, "%us-%uus: %s [%u:%s:%s:%u]: %s",

va_list argList;

sec,

usec,

TRACE_COMPONENT_LIST[traceComponent],

System::getPID(),

Threads::id().buffer,

fileName,

lineNum,

cstring);

va_start(argList,fmt);

// Call trace file handler to write message

_trace(fileName,lineNum,traceComponent,traceLevel,fmt,argList);

_getInstance()->_traceHandler->handleMessage(message,msgLen);

va_end(argList);

}

void Tracer::trace(

delete [] message;

const char* fileName,

const Uint32 lineNum,

const Uint32 traceComponent,

const Uint32 traceLevel,

const String& traceString)

{

if (_traceOn)

{

_traceString( fileName, lineNum, traceComponent, traceLevel,

traceString );

}

void Tracer::traceCIMException(

const Uint32 traceComponent,

const Uint32 traceLevel,

CIMException cimException)

const CIMException& cimException)

{

if (_traceOn)

if (isTraceEnabled(traceComponent, traceLevel))

{

_traceCIMException( traceComponent, traceLevel, cimException );

_traceCIMException(traceComponent, cimException);

}

void Tracer::trace(

const Uint32 traceComponent,

const Uint32 level,

const String& string)

{

trace("unknown", 0, traceComponent, level, string);

}

#endif /* !PEGASUS_REMOVE_TRACE */

Legend:

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

No CVS admin address has been configured