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.1.2.1 and 1.34

version 1.1.2.1, 2001/07/31 23:57:08

version 1.34, 2006/01/30 16:17:08

Line 1

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

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

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

// Author: Sushma Fernandes, Hewlett-Packard Company (sushma_fernandes@hp.com)

// Modified By:

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

#include <Pegasus/Common/Thread.h>

#include <Pegasus/Common/IPC.h>

#include <Pegasus/Common/System.h>

PEGASUS_USING_STD;

Line 43

Line 60

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

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

// Set the return codes

const Boolean Tracer::_SUCCESS = 1;

const Boolean Tracer::_FAILURE = 0;

// Set the Enter and Exit messages

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

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

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

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

// Set Log messages

const char Tracer::_LOG_MSG1[] = "LEVEL1 not enabled with Tracer::trace call.";

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

const char Tracer::_LOG_MSG2[]="Use trace macros, PEG_FUNC_ENTER/PEG_FUNC_EXIT";

// Initialize singleton instance of Tracer

Tracer* Tracer::_tracerInstance = 0;

Line 61

Line 81

const Uint32 Tracer::_NUM_COMPONENTS =

sizeof(TRACE_COMPONENT_LIST)/sizeof(TRACE_COMPONENT_LIST[0]);

// Set the line maximum

const Uint32 Tracer::_STRLEN_MAX_UNSIGNED_INT = 21;

// Set the max PID and Thread ID Length

const Uint32 Tracer::_STRLEN_MAX_PID_TID = 20;

// Initialize public indicator of trace state

Boolean Tracer::_traceOn = false;

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

// Tracer constructor

// Constructor is private to preclude construction of Tracer objects

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

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

Tracer::Tracer()

: _traceComponentMask(new Boolean[_NUM_COMPONENTS]),

_traceLevelMask(0),

_traceHandler(new TraceFileHandler())

{

// Initialize Trace File Handler

_traceHandler=new TraceFileHandler();

_traceLevelMask=0;

_traceComponentMask=new Boolean[_NUM_COMPONENTS];

// Initialize ComponentMask array to false

for (int index=0;index < _NUM_COMPONENTS;

for (Uint32 index=0;index < _NUM_COMPONENTS;

_traceComponentMask[index++]=false);

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

}

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

Line 83

Line 110

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

Tracer::~Tracer()

{

delete []_traceComponentMask;

delete _traceHandler;

delete _tracerInstance;

}

Line 100

Line 125

{

if ( traceLevel == LEVEL1 )

{

// ATTN: Setting the Log file type to DEBUG_LOG

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

// May need to change to an appropriate log file type

Logger::put(Logger::DEBUG_LOG,"Tracer",Logger::WARNING,"$0 $1",

_LOG_MSG1,_LOG_MSG2);

}

else

{

Line 129

Line 151

if ( traceLevel == LEVEL1 )

{

Logger::put(Logger::DEBUG_LOG,"Tracer",Logger::WARNING,"$0 $1",

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

_LOG_MSG1,_LOG_MSG2);

}

else

{

if (_isTraceEnabled(traceComponent,traceLevel))

{

message = new char[strlen(fileName)+strlen(ltoa((long)lineNum))+6];

sprintf(message,"[%s:%d]: ",fileName,lineNum);

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

sprintf(

message,

#if defined(PEGASUS_OS_VMS)

// pegasus_thread_self returns long-long-unsigned.

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

// "[%x:%llx:%s:%u]: ",

System::getPID(),

pegasus_thread_self(),

#else

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

System::getPID(),

Uint32(pegasus_thread_self()),

#endif

fileName,

lineNum);

_trace(traceComponent,message,fmt,argList);

delete []message;

}

Line 145

Line 188

}

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

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

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 =

TraceableCIMException(cimException).getTraceDescription();

// trace the string

_traceString(traceComponent, traceLevel, traceMsg);

}

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

//Traces method entry

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

void Tracer::_traceEnter(

Line 159

Line 332

if (_isTraceEnabled(traceComponent,LEVEL1))

{

va_start(argList,fmt);

message = new char[strlen(fileName)+strlen(ltoa((long)lineNum))+6];

sprintf(message,"[%s:%d]: ",fileName,lineNum);

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

#if defined(PEGASUS_OS_VMS)

// pegasus_thread_self returns long-long-unsigned.

sprintf(

message,

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

System::getPID(),

pegasus_thread_self(),

fileName,

lineNum);

#else

sprintf(

message,

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

System::getPID(),

Uint32(pegasus_thread_self()),

fileName,

lineNum);

#endif

_trace(traceComponent,message,fmt,argList);

va_end(argList);

delete []message;

}

Line 184

Line 385

if (_isTraceEnabled(traceComponent,LEVEL1))

{

va_start(argList,fmt);

message = new char[strlen(fileName)+strlen(ltoa((long)lineNum))+6];

sprintf(message,"[%s:%d]: ",fileName,lineNum);

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

#if defined(PEGASUS_OS_VMS)

// pegasus_thread_self returns long-long-unsigned.

sprintf(

message,

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

System::getPID(),

pegasus_thread_self(),

fileName,

lineNum);

#else

sprintf(

message,

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

System::getPID(),

Uint32(pegasus_thread_self()),

fileName,

lineNum);

#endif

_trace(traceComponent,message,fmt,argList);

va_end(argList);

delete []message;

}

Line 199

Line 427

const Uint32 traceLevel)

{

Tracer* instance = _getInstance();

if ((traceComponent < 0) || (traceComponent >= _NUM_COMPONENTS ))

if (traceComponent >= _NUM_COMPONENTS)

{

return false;

}

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

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

(traceLevel & instance->_traceLevelMask));

}

Line 217

Line 445

va_list argList)

{

char* msgHeader;

Uint32 retCode;

// Get the current system time and prepend to message

String currentTime = System::getCurrentASCIITime();

ArrayDestroyer<char> timeStamp(currentTime.allocateCString());

CString timeStamp = currentTime.getCString();

// Allocate messageHeader.

msgHeader = new char [strlen(message)

// Needs to be updated if additional info is added

+ strlen(TRACE_COMPONENT_LIST[traceComponent])

+ strlen(timeStamp.getPointer()) + 6];

// Construct the message header

// The message header is in the following format

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

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

if (*message != '\0')

{

sprintf(msgHeader,"%s: %s %s",timeStamp.getPointer(),

// << 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(timeStamp) + _STRLEN_MAX_PID_TID + 5];

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

TRACE_COMPONENT_LIST[traceComponent] ,message);

//delete [] msgHeader;

}

else

{

sprintf(msgHeader,"%s: %s ",timeStamp.getPointer(),

TRACE_COMPONENT_LIST[traceComponent] );

// 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[_STRLEN_MAX_PID_TID + 6];

#if defined(PEGASUS_OS_VMS)

// pegasus_thread_self returns long-long-unsigned.

sprintf(tmpBuffer, "[%u:%llu]: ", System::getPID(),

pegasus_thread_self());

#else

sprintf(tmpBuffer, "[%u:%u]: ", System::getPID(),

Uint32(pegasus_thread_self()));

#endif

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

strlen(tmpBuffer) + 1 + 5 ];

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

TRACE_COMPONENT_LIST[traceComponent] ,tmpBuffer );

delete []tmpBuffer;

//delete [] msgHeader;

}

// Call trace file handler to write message

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

delete []msgHeader;

}

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

//Set the trace file

//Validate the trace file

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

Uint32 Tracer::setTraceFile(const char* traceFile)

Boolean Tracer::isValidFileName(const char* filePath)

{

ofstream outFile;

String moduleName = _getInstance()->_moduleName;

Uint32 retCode = 0;

if (moduleName == String::EMPTY)

{

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

}

else

{

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

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

extendedFilePath.getCString()));

}

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

//Validate the trace components

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

Boolean Tracer::isValidComponents(const String& traceComponents)

{

String invalidComponents;

return isValidComponents(traceComponents, invalidComponents);

}

// Check if the file can be opened in append mode

Boolean Tracer::isValidComponents(

if (traceFile)

const String& traceComponents, String& invalidComponents)

{

outFile.open(traceFile,ofstream::app);

// 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 componentStr = String::EMPTY;

Boolean validComponent=false;

Boolean retCode=true;

componentStr = traceComponents;

invalidComponents = String::EMPTY;

if (outFile.good())

if (componentStr != String::EMPTY)

{

// Check if ALL is specified

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

{

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

return _SUCCESS;

outFile.close();

}

// Append _COMPONENT_SEPARATOR to the end of the traceComponents

componentStr.append(_COMPONENT_SEPARATOR);

while (componentStr != String::EMPTY)

{

// Get the Component name from traceComponents.

// Components are separated by _COMPONENT_SEPARATOR

position = componentStr.find(_COMPONENT_SEPARATOR);

componentName = componentStr.subString(0,(position));

// Lookup the index for Component name in TRACE_COMPONENT_LIST

index = 0;

validComponent = false;

while (index < _NUM_COMPONENTS)

{

if (String::equalNoCase(

componentName, TRACE_COMPONENT_LIST[index]))

{

// Found component, break from the loop

validComponent = true;

break;

}

else

{

outFile.close();

index++;

retCode = 1;

}

// Remove the searched componentname from the traceComponents

componentStr.remove(0,position+1);

if ( !validComponent )

{

invalidComponents.append(componentName);

invalidComponents.append(_COMPONENT_SEPARATOR);

}

else

{

retCode=1;

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

return _SUCCESS;

}

if ( invalidComponents != String::EMPTY )

{

retCode = false;

// Remove the extra ',' at the end

invalidComponents.remove(

invalidComponents.reverseFind(_COMPONENT_SEPARATOR));

}

return retCode;

}

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

//Set the name of the module being traced

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

void Tracer::setModuleName(const String& moduleName)

{

_getInstance()->_moduleName = moduleName;

}

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

//Returns the Singleton instance of the Tracer

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

Tracer* Tracer::_getInstance()

{

if (_tracerInstance == 0)

{

_tracerInstance = new Tracer();

}

return _tracerInstance;

}

// PEGASUS_REMOVE_TRACE defines the compile time inclusion of the Trace

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

#ifndef PEGASUS_REMOVE_TRACE

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

//Set the trace file

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

Uint32 Tracer::setTraceFile(const char* traceFile)

{

if (*traceFile == 0)

{

return 1;

}

String moduleName = _getInstance()->_moduleName;

if (moduleName == String::EMPTY)

{

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

}

else

{

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

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

extendedTraceFile.getCString()));

}

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

//Set the trace level

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

Uint32 Tracer::setTraceLevel(const Uint32 traceLevel)

Line 312

Line 700

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

//Set components to be traced.

//The String traceComponents will be updated within the function.

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

void Tracer::setTraceComponents(String traceComponents)

void Tracer::setTraceComponents(const String& traceComponents)

{

Uint32 position=0;

Uint32 index=0;

String componentName;

String componentName = String::EMPTY;

String componentStr = traceComponents;

String invalidComponents = String::EMPTY;

if (traceComponents != String::EMPTY)

if (componentStr != String::EMPTY)

{

// Check if ALL is specified

if (traceComponents == "ALL")

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

{

for (int index=0; index < _NUM_COMPONENTS;

for (index=0; index < _NUM_COMPONENTS;

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

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

_traceOn = true;

return;

}

// initialise ComponentMask array to False

for (int index = 0;index < _NUM_COMPONENTS;

for (index = 0;index < _NUM_COMPONENTS;

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

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

_traceOn = false;

// Append _COMPONENT_SEPARATOR to the end of the traceComponents

traceComponents += _COMPONENT_SEPARATOR;

componentStr.append(_COMPONENT_SEPARATOR);

while (traceComponents != String::EMPTY)

while (componentStr != String::EMPTY)

{

// Get the Component name from traceComponents.

// Components are separated by _COMPONENT_SEPARATOR

position = traceComponents.find(_COMPONENT_SEPARATOR);

position = componentStr.find(_COMPONENT_SEPARATOR);

componentName = traceComponents.subString(0,(position));

componentName = componentStr.subString(0,(position));

// Lookup the index for Component name in TRACE_COMPONENT_LIST

index = 0;

while (index < _NUM_COMPONENTS)

{

if (componentName == TRACE_COMPONENT_LIST[index])

if (String::equalNoCase(

componentName,TRACE_COMPONENT_LIST[index]))

{

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

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

_traceOn = true;

// Found component, break from the loop

break;

Line 362

Line 755

}

// Remove the searched componentname from the traceComponents

traceComponents.remove(0,position+1);

componentStr.remove(0,position+1);

}

else

{

// initialise ComponentMask array to False

for (int index = 0;index < _NUM_COMPONENTS;

for (Uint32 index = 0;index < _NUM_COMPONENTS;

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

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

_traceOn = 0;

}

return ;

}

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

#endif

//Returns the Singleton instance of the Tracer

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

Tracer* Tracer::_getInstance()

{

if (_tracerInstance == 0)

{

_tracerInstance = new Tracer();

}

return _tracerInstance;

}

PEGASUS_NAMESPACE_END

Legend:

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

No CVS admin address has been configured