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.51 and 1.56

version 1.51, 2008/06/26 18:32:39

version 1.56, 2008/10/22 08:11:24

Line 32

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

#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/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 tracer uses the _traceComponentMask in form of a 64bit field to mask

the user configured components.

Please ensure that no more than 64 components are specified in the

TRACE_COMPONENT_LIST.

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,

Line 52

Line 122

{

"File",

"Log",

"Memory",

};

Line 89

Line 160

// Initialize public indicator of trace state

Boolean Tracer::_traceOn = false;

Uint32 Tracer::_traceLevelMask=0;

Uint64 Tracer::_traceComponentMask=(Uint64)0;

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

// Tracer constructor

Line 96

Line 169

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

_traceLevelMask(0),

_runningOOP(false),

_traceHandler(0)

{

// Instantiate trace handler according to configured facility

_traceHandler.reset( getTraceHandler(_traceFacility) );

// Initialize ComponentMask array to false

// The tracer uses a 64bit field to mask the user configured components.

for (Uint32 index=0;index < _NUM_COMPONENTS;

// This assert ensures that no more than 64 components are specified in the

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

// TRACE_COMPONENT_LIST.

PEGASUS_ASSERT(_NUM_COMPONENTS <= 64);

// NO componets are set

// Instantiate trace handler according to configured facility

_componentsAreSet=false;

_setTraceHandler(_traceFacility);

}

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

Line 117

Line 189

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

Tracer::~Tracer()

{

delete _traceHandler;

delete _tracerInstance;

}

Line 124

Line 197

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

//Factory function for the trace handler instances.

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

TraceHandler* Tracer::getTraceHandler( Uint32 traceFacility )

void Tracer::_setTraceHandler( Uint32 traceFacility )

{

TraceHandler * trcHandler;

TraceHandler * oldTrcHandler = _traceHandler;

switch(traceFacility)

{

case TRACE_FACILITY_LOG:

trcHandler = new TraceLogHandler();

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

trcHandler = new TraceFileHandler();

_traceFacility = TRACE_FACILITY_FILE;

_traceHandler = new TraceFileHandler();

}

delete oldTrcHandler;

}

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

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

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

Boolean Tracer::_isValidTraceFile(String fileName)

{

// Check if the file path is a directory

FileSystem::translateSlashes(fileName);

if (FileSystem::isDirectory(fileName))

{

return false;

}

return trcHandler;

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

Line 274

void Tracer::_trace(

const char* fileName,

const Uint32 lineNum,

const Uint32 traceComponent,

const TraceComponentId traceComponent,

const char* fmt,

va_list argList)

{

Line 174

Line 301

//Traces the message in the given CIMException object.

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

void Tracer::_traceCIMException(

const Uint32 traceComponent,

const TraceComponentId traceComponent,

const CIMException& cimException)

{

// get the CIMException trace message string

Line 231

Line 358

void Tracer::_traceMethod(

const char* fileName,

const Uint32 lineNum,

const Uint32 traceComponent,

const TraceComponentId traceComponent,

const char* methodEntryExit,

const char* method)

{

Line 261

Line 388

delete [] message;

}

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

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

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

Boolean Tracer::isTraceEnabled(

const Uint32 traceComponent,

const Uint32 traceLevel)

{

Tracer* instance = _getInstance();

if (traceComponent >= _NUM_COMPONENTS)

{

return false;

}

return (((instance->_traceComponentMask.get())[traceComponent]) &&

(traceLevel & instance->_traceLevelMask));

}

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

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

Line 302

Line 413

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

msgHeader = new char [strlen(message) +

strlen(TRACE_COMPONENT_LIST[traceComponent]) +

strlen(TRACE_COMPONENT_LIST[traceComponent]) + 30];

strlen(timeStamp) + _STRLEN_MAX_PID_TID + 5];

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

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

TRACE_COMPONENT_LIST[traceComponent], message);

}

else

{

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

char* tmpBuffer;

// Allocate messageHeader.

// Needs to be updated if additional info is added

tmpBuffer = new char[2 * _STRLEN_MAX_PID_TID + 6];

// Format string length calculation:

sprintf(tmpBuffer, "[%u:%s]: ",

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

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

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

msgHeader = new char[strlen(timeStamp) +

msgHeader = new char[2 * _STRLEN_MAX_PID_TID +

strlen(TRACE_COMPONENT_LIST[traceComponent]) +

strlen(TRACE_COMPONENT_LIST[traceComponent]) + 35];

strlen(tmpBuffer) + 1 + 5];

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

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

TRACE_COMPONENT_LIST[traceComponent], tmpBuffer);

TRACE_COMPONENT_LIST[traceComponent],

delete [] tmpBuffer;

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

}

// Call trace file handler to write message

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

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

delete [] msgHeader;

}

Line 347

Line 452

//to log message to trace file

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

void Tracer::_traceCString(

const Uint32 traceComponent,

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

String currentTime = System::getCurrentASCIITime();

System::getCurrentTimeUsec(sec,usec);

CString timeStamp = currentTime.getCString();

// Allocate completeMessage.

// Needs to be updated if additional info is added

Line 364

Line 471

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

strlen(TRACE_COMPONENT_LIST[traceComponent]) +

strlen(timeStamp) + _STRLEN_MAX_PID_TID + 5 +

strlen(cstring) + 30];

strlen(cstring) ];

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

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

TRACE_COMPONENT_LIST[traceComponent], message, cstring);

}

else

Line 387

Line 494

// Allocate messageHeader.

// Needs to be updated if additional info is added

tmpBuffer = new char[2 * _STRLEN_MAX_PID_TID + 6];

// Format string length calculation:

sprintf(tmpBuffer, "[%u:%s]: ",

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

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

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

completeMessage = new char[2 * _STRLEN_MAX_PID_TID +

completeMessage = new char[strlen(timeStamp) +

strlen(TRACE_COMPONENT_LIST[traceComponent]) +

strlen(tmpBuffer) + 1 + 5 +

strlen(cstring) +35];

strlen(cstring)];

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

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

TRACE_COMPONENT_LIST[traceComponent], tmpBuffer, cstring);

TRACE_COMPONENT_LIST[traceComponent],

delete [] tmpBuffer;

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

cstring);

}

// Call trace file handler to write message

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

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

delete [] completeMessage;

}

Line 413

Line 519

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

Boolean Tracer::isValidFileName(const char* filePath)

{

String moduleName = _getInstance()->_moduleName;

Tracer* instance = _getInstance();

if (moduleName == String::EMPTY)

String testTraceFile(filePath);

{

return

if (instance->_runningOOP)

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

}

else

{

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

testTraceFile.append(".");

return _getInstance()->_traceHandler->isValidMessageDestination(

testTraceFile.append(instance->_oopTraceFileExtension);

extendedFilePath.getCString());

}

return _isValidTraceFile(testTraceFile);

}

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

Line 545

Line 649

}

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

//Set the name of the module being traced

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

// for the out of process trace file.

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

void Tracer::setModuleName(const String& moduleName)

void Tracer::setOOPTraceFileExtension(const String& oopTraceFileExtension)

{

_getInstance()->_moduleName = moduleName;

Tracer* instance = _getInstance();

instance->_oopTraceFileExtension = oopTraceFileExtension;

instance->_runningOOP=true;

instance->_traceMemoryBufferSize /= PEGASUS_TRC_BUFFER_OOP_SIZE_DEVISOR;

}

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

Line 581

Line 690

return 1;

}

String moduleName = _getInstance()->_moduleName;

Tracer* instance = _getInstance();

if (moduleName == String::EMPTY)

String newTraceFile(traceFile);

if (instance->_runningOOP)

{

newTraceFile.append(".");

newTraceFile.append(instance->_oopTraceFileExtension);

}

if (_isValidTraceFile(newTraceFile))

{

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

instance->_traceFile = newTraceFile;

instance->_traceHandler->configurationUpdated();

}

else

{

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

return 1;

return _getInstance()->_traceHandler->setMessageDestination(

extendedTraceFile.getCString());

}

return 0;

}

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

Line 604

Line 724

switch (traceLevel)

{

case LEVEL0:

_getInstance()->_traceLevelMask = 0x00;

_traceLevelMask = 0x00;

break;

case LEVEL1:

_getInstance()->_traceLevelMask = 0x01;

_traceLevelMask = 0x01;

break;

case LEVEL2:

_getInstance()->_traceLevelMask = 0x03;

_traceLevelMask = 0x03;

break;

case LEVEL3:

_getInstance()->_traceLevelMask = 0x07;

_traceLevelMask = 0x07;

break;

case LEVEL4:

_getInstance()->_traceLevelMask = 0x0F;

_traceLevelMask = 0x0F;

break;

case LEVEL5:

_getInstance()->_traceLevelMask = 0x1F;

_traceLevelMask = 0x1F;

break;

default:

_getInstance()->_traceLevelMask = 0x00;

_traceLevelMask = 0x00;

retCode = 1;

}

if (_getInstance()->_componentsAreSet &&

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

_getInstance()->_traceLevelMask )

// is not zero, then turn on tracing.

{

_traceOn=((_traceComponentMask!=(Uint64)0)&&(_traceLevelMask!=LEVEL0));

_traceOn = true;

}

else

{

_traceOn = false;

}

return retCode;

}

Line 650

Line 764

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

void Tracer::setTraceComponents(const String& traceComponents)

{

Tracer* instance = _getInstance();

// Check if ALL is specified

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

{

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

// initialize ComponentMask bit array to true

{

_traceComponentMask = (Uint64)-1;

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

_traceOn = (_traceLevelMask != LEVEL0);

return;

}

// initialize ComponentMask array to False

// initialize ComponentMask bit array to false

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

_traceComponentMask = (Uint64)0;

{

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

}

_traceOn = false;

instance->_componentsAreSet=false;

if (traceComponents != String::EMPTY)

{

Line 702

Line 806

if (String::equalNoCase(

componentName,TRACE_COMPONENT_LIST[index]))

{

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

_traceComponentMask=_traceComponentMask|((Uint64)1<<index);

instance->_componentsAreSet=true;

// Found component, break from the loop

break;

}

Line 714

Line 815

index++;

}

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

_traceOn=((_traceComponentMask!=(Uint64)0)&&(_traceLevelMask!=LEVEL0));

(instance->_traceLevelMask != LEVEL0));

}

return ;

Line 745

Line 843

{

if (index != instance->_traceFacility)

{

instance->_traceFacility = index;

instance->_setTraceHandler(index);

instance->_traceHandler.reset(

instance->getTraceHandler(instance->_traceFacility));

}

retCode = 1;

break;

Line 767

Line 863

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

{

instance->_traceMemoryBufferSize = bufferSize;

}

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

}

void Tracer::traceEnter(

TracerToken& token,

const char* file,

size_t line,

Uint32 traceComponent,

TraceComponentId traceComponent,

const char* method)

{

token.component = traceComponent;

Line 803

Line 933

void Tracer::traceCString(

const char* fileName,

const Uint32 lineNum,

const Uint32 traceComponent,

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_MAX_UNSIGNED_INT + (_STRLEN_MAX_PID_TID * 2) + 8 +

sprintf(

strlen(TRACE_COMPONENT_LIST[traceComponent]) +

message,

strlen(cstring) + 30];

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

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

sec,

usec,

TRACE_COMPONENT_LIST[traceComponent],

System::getPID(),

Threads::id().buffer,

fileName,

lineNum);

lineNum,

cstring);

// Call trace file handler to write message

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

_traceCString(traceComponent, message, cstring);

delete [] message;

}

void Tracer::traceCIMException(

const Uint32 traceComponent,

const TraceComponentId traceComponent,

const Uint32 traceLevel,

const CIMException& cimException)

{

Legend:

Removed from v.1.51
changed lines
	Added in v.1.56

No CVS admin address has been configured