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.23 and 1.55

version 1.23, 2004/06/22 22:06:23

version 1.55, 2008/10/01 08:35:46

Line 1

//%2003////////////////////////////////////////////////////////////////////////

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

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

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

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

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

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)

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

#include <Pegasus/Common/Config.h>

#include <Pegasus/Common/Constants.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/IPC.h>

#include <Pegasus/Common/System.h>

#include <Pegasus/Common/HTTPMessage.h>

#include <Pegasus/Common/StringConversion.h>

#include <Pegasus/Common/FileSystem.h>

PEGASUS_USING_STD;

PEGASUS_NAMESPACE_BEGIN

/**

String constants for naming the various Trace components.

These strings will used when turning on tracing for the respective

components. The component list must be kept in sync with the

TraceComponentId enumeration.

The following example shows the usage of trace component names.

The setTraceComponents method is used to turn on tracing for the

components: Config and Repository. The component names are passed as a

comma separated list.

Tracer::setTraceComponents("Config,Repository");

static char const* TRACE_COMPONENT_LIST[] =

{

"XmlParser",

"XmlWriter",

"XmlReader",

"XmlIO",

"Http",

"CimData",

"Repository",

"Dispatcher",

"OsAbstraction",

"Config",

"IndHandler",

"Authentication",

"Authorization",

"UserManager",

"Registration",

"Shutdown",

"Server",

"IndicationService",

"IndicationServiceInternal",

"MessageQueueService",

"ProviderManager",

"ObjectResolution",

"WQL",

"CQL",

"Thread",

"IPC",

"IndicationHandlerService",

"CIMExportRequestDispatcher",

"SSL",

"ControlProvider",

"CIMOMHandle",

"BinaryMessageHandler",

"L10N",

"ExportClient",

"Listener",

"DiscardedData",

"ProviderAgent",

"IndicationFormatter",

"StatisticalData",

"CMPIProvider",

"IndicationGeneration",

"IndicationReceipt",

"CMPIProviderInterface",

"WsmServer",

"LogMessages"

};

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

Line 151

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;

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

// Tracer constructor

Line 83

Line 162

// Single Instance of Tracer is maintained for each process.

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

Tracer::Tracer()

: _traceComponentMask(new Boolean[_NUM_COMPONENTS]),

_traceMemoryBufferSize(PEGASUS_TRC_DEFAULT_BUFFER_SIZE_KB),

_traceFacility(TRACE_FACILITY_FILE),

_runningOOP(false),

_traceLevelMask(0),

_traceHandler(0)

{

// Initialize Trace File Handler

// Instantiate trace handler according to configured facility

_traceHandler.reset(new TraceFileHandler());

_setTraceHandler(_traceFacility);

_traceLevelMask=0;

_traceComponentMask.reset(new Boolean[_NUM_COMPONENTS]);

// Initialize ComponentMask array to false

for (Uint32 index=0;index < _NUM_COMPONENTS;

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

// NO componets are set

_componentsAreSet=false;

}

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

Line 99

Line 185

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

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 )

TraceHandler * oldTrcHandler = _traceHandler;

switch(traceFacility)

{

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

case TRACE_FACILITY_LOG:

_traceFacility = TRACE_FACILITY_LOG;

_traceHandler = new TraceLogHandler();

break;

case TRACE_FACILITY_MEMORY:

_traceFacility = TRACE_FACILITY_MEMORY;

_traceHandler = new TraceMemoryHandler();

break;

case TRACE_FACILITY_FILE:

default:

_traceFacility = TRACE_FACILITY_FILE;

_traceHandler = new TraceFileHandler();

}

else

delete oldTrcHandler;

}

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

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

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

Boolean Tracer::_isValidTraceFile(String fileName)

{

if (_isTraceEnabled(traceComponent,traceLevel))

// Check if the file path is a directory

FileSystem::translateSlashes(fileName);

if (FileSystem::isDirectory(fileName))

{

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

return false;

}

// Check if the file exists and is writable

if (FileSystem::exists(fileName))

{

return FileSystem::canWrite(fileName);

}

// Check if directory is writable

Uint32 index = fileName.reverseFind('/');

if (index != PEG_NOT_FOUND)

{

String dirName = fileName.subString(0,index);

if (dirName.size() == 0)

{

dirName = "/";

}

if (!FileSystem::isDirectory(dirName))

{

return false;

}

return FileSystem::canWrite(dirName);

}

String currentDir;

// Check if there is permission to write in the

// current working directory

FileSystem::getCurrentDirectory(currentDir);

return FileSystem::canWrite(currentDir);

}

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

Line 131

Line 270

void Tracer::_trace(

const char* fileName,

const Uint32 lineNum,

const Uint32 traceComponent,

const TraceComponentId 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 154

Line 283

_STRLEN_MAX_UNSIGNED_INT + (_STRLEN_MAX_PID_TID * 2) + 8 ];

sprintf(

message,

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

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

System::getPID(),

Uint32(pegasus_thread_self()),

Threads::id().buffer,

fileName,

lineNum);

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

}

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

//Traces method entry

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

void Tracer::_traceEnter(

const char* fileName,

const Uint32 lineNum,

const Uint32 traceComponent,

const char* fmt,

...)

{

va_list argList;

char* message;

if (_isTraceEnabled(traceComponent,LEVEL1))

SharedArrayPtr<char> Tracer::getHTTPRequestMessage(

const Buffer& requestMessage)

{

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:%u:%s:%u]: ",

(line != sep))

System::getPID(),

{

Uint32(pegasus_thread_self()),

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

fileName,

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

lineNum);

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

_trace(traceComponent,message,fmt,argList);

{

// Suppress the user/passwd info

HTTPMessage::skipHeaderWhitespace(line);

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

userpass < sep;

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

va_end(argList);

break;

delete []message;

}

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

}

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 TraceComponentId 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:%u:%s:%u]: ",

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

System::getPID(),

Uint32(pegasus_thread_self()),

Threads::id().buffer,

fileName,

lineNum);

lineNum,

_trace(traceComponent,message,fmt,argList);

methodEntryExit);

va_end(argList);

_traceCString(traceComponent, message, method);

delete []message;

}

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

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

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

Boolean Tracer::_isTraceEnabled(const Uint32 traceComponent,

Boolean Tracer::isTraceEnabled(

const TraceComponentId traceComponent,

const Uint32 traceLevel)

{

Tracer* instance = _getInstance();

if (traceComponent >= _NUM_COMPONENTS)

if (Uint32(traceComponent) >= _NUM_COMPONENTS)

{

return false;

}

Line 389

Line 402

}

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

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

const TraceComponentId traceComponent,

const char* message,

const char* fmt,

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

if (strcmp(message,"") != 0)

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

Line 507

// 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:%u]: ", System::getPID(),

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

Uint32(pegasus_thread_self()));

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

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

completeMessage = new char[2 * _STRLEN_MAX_PID_TID +

strlen(tmpBuffer) + 1 + 5 ];

strlen(TRACE_COMPONENT_LIST[traceComponent]) +

strlen(cstring) +35];

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

TRACE_COMPONENT_LIST[traceComponent] ,tmpBuffer );

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

delete []tmpBuffer;

TRACE_COMPONENT_LIST[traceComponent],

//delete [] msgHeader;

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

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

Boolean Tracer::isValidFileName(const char* filePath)

{

String moduleName = _getInstance()->_moduleName;

Tracer* instance = _getInstance();

if (moduleName == String::EMPTY)

String testTraceFile(filePath);

{

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

if (instance->_runningOOP)

}

else

{

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

testTraceFile.append(".");

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

testTraceFile.append(instance->_oopTraceFileExtension);

extendedFilePath.getCString()));

}

return _isValidTraceFile(testTraceFile);

}

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

Line 482

Line 554

}

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 502

Line 575

// Check if ALL is specified

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

{

return _SUCCESS;

return true;

}

// Append _COMPONENT_SEPARATOR to the end of the traceComponents

Line 549

Line 622

else

{

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

return _SUCCESS;

return true;

}

if ( invalidComponents != String::EMPTY )

{

retCode = false;

Line 564

Line 638

}

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

//Set the name of the module being traced

//Validate the trace facility

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

void Tracer::setModuleName(const String& moduleName)

Boolean Tracer::isValidTraceFacility(const String& traceFacility)

{

Boolean retCode = false;

if (traceFacility.size() != 0)

{

Uint32 index = 0;

while (TRACE_FACILITY_LIST[index] != 0 )

{

_getInstance()->_moduleName = moduleName;

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

{

retCode = true;

break;

}

index++;

}

return retCode;

}

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

// Notify the trare running out of process and provide the trace file extension

// for the out of process trace file.

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

void Tracer::setOOPTraceFileExtension(const String& oopTraceFileExtension)

{

Tracer* instance = _getInstance();

instance->_oopTraceFileExtension = oopTraceFileExtension;

instance->_runningOOP=true;

instance->_traceMemoryBufferSize /= PEGASUS_TRC_BUFFER_OOP_SIZE_DEVISOR;

}

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

Line 584

Line 687

}

// PEGASUS_REMOVE_TRACE defines the compile time inclusion of the Trace

// interfaces. If defined the interfaces map to empty functions

// interfaces. This section defines the trace functions IF the remove

// trace flag is NOT set. If it is set, they are defined as empty functions

// in the header file.

#ifndef PEGASUS_REMOVE_TRACE

Line 593

Line 698

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

Uint32 Tracer::setTraceFile(const char* traceFile)

{

String moduleName = _getInstance()->_moduleName;

if (*traceFile == 0)

if (moduleName == String::EMPTY)

{

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

return 1;

}

Tracer* instance = _getInstance();

String newTraceFile(traceFile);

if (instance->_runningOOP)

{

newTraceFile.append(".");

newTraceFile.append(instance->_oopTraceFileExtension);

}

if (_isValidTraceFile(newTraceFile))

{

instance->_traceFile = newTraceFile;

instance->_traceHandler->configurationUpdated();

}

else

{

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

return 1;

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

extendedTraceFile.getCString()));

}

return 0;

}

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

Line 615

Line 736

switch (traceLevel)

{

case LEVEL0:

_getInstance()->_traceLevelMask = 0x00;

break;

case LEVEL1:

_getInstance()->_traceLevelMask = 0x01;

break;

Line 631

Line 756

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

Line 783

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

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 (Uint32 index = 0; index < _NUM_COMPONENTS; index++)

{

for (index=0; index < _NUM_COMPONENTS;

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

(_getInstance()->_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 680

Line 835

if (String::equalNoCase(

componentName,TRACE_COMPONENT_LIST[index]))

{

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

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

instance->_componentsAreSet=true;

// Found component, break from the loop

break;

Line 694

Line 851

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

}

return ;

}

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

// Set the trace facility to be used

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

Uint32 Tracer::setTraceFacility(const String& traceFacility)

{

Uint32 retCode = 0;

Tracer* instance = _getInstance();

if (traceFacility.size() != 0)

{

Uint32 index = 0;

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

}

return retCode;

}

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

// Get the trace facility in use

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

Uint32 Tracer::getTraceFacility()

{

return _getInstance()->_traceFacility;

}

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

// Set the size of the memory trace buffer

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

Boolean Tracer::setTraceMemoryBufferSize(Uint32 bufferSize)

{

Tracer* instance = _getInstance();

if (instance->_runningOOP)

{

// in OOP we reduce the trace memory buffer by factor

// PEGASUS_TRC_BUFFER_OOP_SIZE_DEVISOR

instance->_traceMemoryBufferSize =

bufferSize / PEGASUS_TRC_BUFFER_OOP_SIZE_DEVISOR;

}

else

{

// initialise ComponentMask array to False

instance->_traceMemoryBufferSize = bufferSize;

for (Uint32 index = 0;index < _NUM_COMPONENTS;

}

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

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

// this is where it needs to be implemented.

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 ;

}

#endif

void Tracer::traceEnter(

TracerToken& token,

const char* file,

size_t line,

TraceComponentId traceComponent,

const char* method)

{

token.component = traceComponent;

token.method = method;

if (isTraceEnabled(traceComponent, LEVEL5))

{

_traceMethod(

file, (Uint32)line, traceComponent,

_METHOD_ENTER_MSG, method);

}

void Tracer::traceExit(

TracerToken& token,

const char* file,

size_t line)

{

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

_traceMethod(

file, (Uint32)line, token.component,

_METHOD_EXIT_MSG, token.method);

}

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

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

//of trace origin.

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

void Tracer::traceCString(

const char* fileName,

const Uint32 lineNum,

const TraceComponentId traceComponent,

const char* cstring)

{

char* message;

Uint32 msgLen;

Uint32 usec,sec;

// Get the current system time

System::getCurrentTimeUsec(sec,usec);

// Allocate memory for the message string

// Needs to be updated if additional info is added

message = new char [strlen(fileName) +

_STRLEN_MAX_UNSIGNED_INT + (_STRLEN_MAX_PID_TID * 2) + 8 +

strlen(TRACE_COMPONENT_LIST[traceComponent]) +

strlen(cstring) + 30];

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

sec,

usec,

TRACE_COMPONENT_LIST[traceComponent],

System::getPID(),

Threads::id().buffer,

fileName,

lineNum,

cstring);

// Call trace file handler to write message

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

delete [] message;

}

void Tracer::traceCIMException(

const TraceComponentId traceComponent,

const Uint32 traceLevel,

const CIMException& cimException)

{

if (isTraceEnabled(traceComponent, traceLevel))

{

_traceCIMException(traceComponent, cimException);

}

#endif /* !PEGASUS_REMOVE_TRACE */

PEGASUS_NAMESPACE_END

Legend:

Removed from v.1.23
changed lines
	Added in v.1.55

No CVS admin address has been configured