version 1.1.2.1, 2001/07/31 23:57:08
|
version 1.47, 2007/09/14 18:33:50
|
|
|
//%///////////////////////////////////////////////////////////////////////////// |
//%2006//////////////////////////////////////////////////////////////////////// |
// | // |
// Copyright (c) 2000, 2001 BMC Software, Hewlett-Packard Company, IBM, |
// Copyright (c) 2000, 2001, 2002 BMC Software; Hewlett-Packard Development |
// The Open Group, Tivoli Systems |
// Company, L.P.; IBM Corp.; The Open Group; Tivoli Systems. |
|
// Copyright (c) 2003 BMC Software; Hewlett-Packard Development Company, L.P.; |
|
// IBM Corp.; EMC Corporation, The Open Group. |
|
// Copyright (c) 2004 BMC Software; Hewlett-Packard Development Company, L.P.; |
|
// IBM Corp.; EMC Corporation; VERITAS Software Corporation; The Open Group. |
|
// Copyright (c) 2005 Hewlett-Packard Development Company, L.P.; IBM Corp.; |
|
// EMC Corporation; VERITAS Software Corporation; The Open Group. |
|
// Copyright (c) 2006 Hewlett-Packard Development Company, L.P.; IBM Corp.; |
|
// EMC Corporation; Symantec Corporation; The Open Group. |
// | // |
// Permission is hereby granted, free of charge, to any person obtaining a copy | // Permission is hereby granted, free of charge, to any person obtaining a copy |
// of this software and associated documentation files (the "Software"), to | // of this software and associated documentation files (the "Software"), to |
|
|
// | // |
//============================================================================== | //============================================================================== |
// | // |
// Author: Sushma Fernandes, Hewlett-Packard Company (sushma_fernandes@hp.com) |
|
// |
|
// Modified By: |
|
// |
|
//%///////////////////////////////////////////////////////////////////////////// | //%///////////////////////////////////////////////////////////////////////////// |
| |
|
#include <Pegasus/Common/Config.h> |
#include <Pegasus/Common/Tracer.h> | #include <Pegasus/Common/Tracer.h> |
#include <Pegasus/Common/Destroyer.h> |
#include <Pegasus/Common/Thread.h> |
|
#include <Pegasus/Common/System.h> |
|
#include <Pegasus/Common/HTTPMessage.h> |
| |
PEGASUS_USING_STD; | PEGASUS_USING_STD; |
| |
|
|
const Uint32 Tracer::LEVEL3 = (1 << 2); | const Uint32 Tracer::LEVEL3 = (1 << 2); |
const Uint32 Tracer::LEVEL4 = (1 << 3); | 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 | // 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 | // Set Log messages |
const char Tracer::_LOG_MSG1[] = "LEVEL1 not enabled with Tracer::trace call."; |
const char Tracer::_LOG_MSG[] = |
const char Tracer::_LOG_MSG2[]="Use trace macros, PEG_FUNC_ENTER/PEG_FUNC_EXIT"; |
"LEVEL1 may only be used with trace macros " |
|
"PEG_METHOD_ENTER/PEG_METHOD_EXIT."; |
| |
// Initialize singleton instance of Tracer | // Initialize singleton instance of Tracer |
Tracer* Tracer::_tracerInstance = 0; | Tracer* Tracer::_tracerInstance = 0; |
|
|
const Uint32 Tracer::_NUM_COMPONENTS = | const Uint32 Tracer::_NUM_COMPONENTS = |
sizeof(TRACE_COMPONENT_LIST)/sizeof(TRACE_COMPONENT_LIST[0]); | 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 = 21; |
|
|
|
// Initialize public indicator of trace state |
|
Boolean Tracer::_traceOn = false; |
|
|
//////////////////////////////////////////////////////////////////////////////// | //////////////////////////////////////////////////////////////////////////////// |
// Tracer constructor | // Tracer constructor |
// Constructor is private to preclude construction of Tracer objects | // Constructor is private to preclude construction of Tracer objects |
// Single Instance of Tracer is maintained for each process. | // Single Instance of Tracer is maintained for each process. |
//////////////////////////////////////////////////////////////////////////////// | //////////////////////////////////////////////////////////////////////////////// |
Tracer::Tracer() | 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 | // 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); |
} | } |
| |
//////////////////////////////////////////////////////////////////////////////// | //////////////////////////////////////////////////////////////////////////////// |
|
|
//////////////////////////////////////////////////////////////////////////////// | //////////////////////////////////////////////////////////////////////////////// |
Tracer::~Tracer() | Tracer::~Tracer() |
{ | { |
delete []_traceComponentMask; |
|
delete _traceHandler; |
|
delete _tracerInstance; | delete _tracerInstance; |
} | } |
| |
| |
//////////////////////////////////////////////////////////////////////////////// | //////////////////////////////////////////////////////////////////////////////// |
//Traces the given message |
|
//////////////////////////////////////////////////////////////////////////////// |
|
void Tracer::_trace( |
|
const Uint32 traceComponent, |
|
const Uint32 traceLevel, |
|
const char* fmt, |
|
va_list argList) |
|
{ |
|
if ( traceLevel == LEVEL1 ) |
|
{ |
|
// ATTN: Setting the Log file type to DEBUG_LOG |
|
// 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 |
|
{ |
|
if (_isTraceEnabled(traceComponent,traceLevel)) |
|
{ |
|
_trace(traceComponent,"",fmt,argList); |
|
} |
|
} |
|
} |
|
|
|
//////////////////////////////////////////////////////////////////////////////// |
|
//Traces the given message - Overloaded for including FileName and Line number | //Traces the given message - Overloaded for including FileName and Line number |
//////////////////////////////////////////////////////////////////////////////// | //////////////////////////////////////////////////////////////////////////////// |
void Tracer::_trace( | void Tracer::_trace( |
const char* fileName, | const char* fileName, |
const Uint32 lineNum, | const Uint32 lineNum, |
const Uint32 traceComponent, | const Uint32 traceComponent, |
const Uint32 traceLevel, |
|
const char* fmt, | const char* fmt, |
va_list argList) | va_list argList) |
{ | { |
char* message; | char* message; |
|
// |
|
// 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, |
|
"[%d:%s:%s:%u]: ", |
|
System::getPID(), |
|
Threads::id().buffer, |
|
fileName, |
|
lineNum); |
| |
if ( traceLevel == LEVEL1 ) |
|
{ |
|
Logger::put(Logger::DEBUG_LOG,"Tracer",Logger::WARNING,"$0 $1", |
|
_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); |
|
_trace(traceComponent,message,fmt,argList); | _trace(traceComponent,message,fmt,argList); |
delete []message; | delete []message; |
} | } |
} |
|
} |
|
| |
//////////////////////////////////////////////////////////////////////////////// | //////////////////////////////////////////////////////////////////////////////// |
//Traces method entry |
//Traces the message in the given CIMException object. |
//////////////////////////////////////////////////////////////////////////////// | //////////////////////////////////////////////////////////////////////////////// |
void Tracer::_traceEnter( |
void Tracer::_traceCIMException( |
const char* fileName, |
|
const Uint32 lineNum, |
|
const Uint32 traceComponent, | const Uint32 traceComponent, |
const char* fmt, |
const CIMException& cimException) |
...) |
|
{ | { |
va_list argList; |
// get the CIMException trace message string |
char* message; |
CString traceMsg = |
|
TraceableCIMException(cimException).getTraceDescription().getCString(); |
|
// trace the string |
|
_traceCString(traceComponent, "", (const char*) traceMsg); |
|
} |
| |
if (_isTraceEnabled(traceComponent,LEVEL1)) |
SharedArrayPtr<char> Tracer::getHTTPRequestMessage( |
|
const Buffer& requestMessage) |
{ | { |
va_start(argList,fmt); |
const Uint32 requestSize = requestMessage.size(); |
message = new char[strlen(fileName)+strlen(ltoa((long)lineNum))+6]; |
|
sprintf(message,"[%s:%d]: ",fileName,lineNum); |
// Make a copy of the request message. |
_trace(traceComponent,message,fmt,argList); |
SharedArrayPtr<char> |
va_end(argList); |
requestBuf(new char [requestSize + 1]); |
delete []message; |
strncpy(requestBuf.get(), requestMessage.getData(), requestSize); |
|
requestBuf.get()[requestSize] = 0; |
|
|
|
// |
|
// Check if requestBuffer contains a Basic authorization header. |
|
// If true, suppress the user/passwd info in the request buffer. |
|
// |
|
char* sep; |
|
const char* line = requestBuf.get(); |
|
|
|
while ((sep = HTTPMessage::findSeparator( |
|
line, (Uint32)(requestSize - (line - requestBuf.get())))) && |
|
(line != sep)) |
|
{ |
|
if (HTTPMessage::expectHeaderToken(line, "Authorization") && |
|
HTTPMessage::expectHeaderToken(line, ":") && |
|
HTTPMessage::expectHeaderToken(line, "Basic")) |
|
{ |
|
// Suppress the user/passwd info |
|
HTTPMessage::skipHeaderWhitespace(line); |
|
for ( char* userpass = (char*)line ; |
|
userpass < sep; |
|
*userpass = 'X', userpass++); |
|
|
|
break; |
|
} |
|
|
|
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 char* fileName, |
const Uint32 lineNum, | const Uint32 lineNum, |
const Uint32 traceComponent, | const Uint32 traceComponent, |
const char* fmt |
const char* methodEntryExit, |
...) |
const char* method) |
{ | { |
va_list argList; |
|
char* message; | char* message; |
| |
if (_isTraceEnabled(traceComponent,LEVEL1)) |
// |
{ |
// Allocate memory for the message string |
va_start(argList,fmt); |
// Needs to be updated if additional info is added |
message = new char[strlen(fileName)+strlen(ltoa((long)lineNum))+6]; |
// |
sprintf(message,"[%s:%d]: ",fileName,lineNum); |
// assume Method entry/exit string 15 characters long |
_trace(traceComponent,message,fmt,argList); |
// +1 space character |
va_end(argList); |
message = new char[ strlen(fileName) + |
|
_STRLEN_MAX_UNSIGNED_INT + (_STRLEN_MAX_PID_TID * 2) + 8 |
|
+ 16]; |
|
|
|
sprintf( |
|
message, |
|
"[%d:%s:%s:%u]: %s ", |
|
System::getPID(), |
|
Threads::id().buffer, |
|
fileName, |
|
lineNum, |
|
methodEntryExit); |
|
|
|
_traceCString(traceComponent, message, method); |
|
|
delete []message; | delete []message; |
} | } |
} |
|
| |
//////////////////////////////////////////////////////////////////////////////// | //////////////////////////////////////////////////////////////////////////////// |
//Checks if trace is enabled for the given component and level | //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) | const Uint32 traceLevel) |
{ | { |
Tracer* instance = _getInstance(); | Tracer* instance = _getInstance(); |
if ((traceComponent < 0) || (traceComponent >= _NUM_COMPONENTS )) |
if (traceComponent >= _NUM_COMPONENTS) |
{ | { |
return false; | return false; |
} | } |
return ((instance->_traceComponentMask[traceComponent]) && |
return (((instance->_traceComponentMask.get())[traceComponent]) && |
(traceLevel & instance->_traceLevelMask)); | (traceLevel & instance->_traceLevelMask)); |
} | } |
| |
//////////////////////////////////////////////////////////////////////////////// | //////////////////////////////////////////////////////////////////////////////// |
//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( | void Tracer::_trace( |
const Uint32 traceComponent, | const Uint32 traceComponent, |
|
|
va_list argList) | va_list argList) |
{ | { |
char* msgHeader; | char* msgHeader; |
Uint32 retCode; |
|
| |
// Get the current system time and prepend to message | // Get the current system time and prepend to message |
String currentTime = System::getCurrentASCIITime(); | String currentTime = System::getCurrentASCIITime(); |
ArrayDestroyer<char> timeStamp(currentTime.allocateCString()); |
CString timeStamp = currentTime.getCString(); |
| |
|
// |
// Allocate messageHeader. | // 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 | // Construct the message header |
// The message header is in the following format | // The message header is in the following format |
// timestamp: <component name> [file name:line number] | // 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); | TRACE_COMPONENT_LIST[traceComponent] ,message); |
} | } |
else | 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[2 * _STRLEN_MAX_PID_TID + 6]; |
|
sprintf(tmpBuffer, "[%u:%s]: ", |
|
System::getPID(), Threads::id().buffer); |
|
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; |
} | } |
| |
// Call trace file handler to write message | // Call trace file handler to write message |
_getInstance()->_traceHandler->handleMessage(msgHeader,fmt,argList); | _getInstance()->_traceHandler->handleMessage(msgHeader,fmt,argList); |
|
|
delete []msgHeader; | delete []msgHeader; |
} | } |
| |
//////////////////////////////////////////////////////////////////////////////// | //////////////////////////////////////////////////////////////////////////////// |
//Set the trace file |
//Called by all trace interfaces using a character string without format string |
|
//to log message to trace file |
//////////////////////////////////////////////////////////////////////////////// | //////////////////////////////////////////////////////////////////////////////// |
Uint32 Tracer::setTraceFile(const char* traceFile) |
void Tracer::_traceCString( |
|
const Uint32 traceComponent, |
|
const char* message, |
|
const char* cstring) |
{ | { |
ofstream outFile; |
char* completeMessage; |
Uint32 retCode = 0; |
|
|
// Get the current system time and prepend to message |
|
String currentTime = System::getCurrentASCIITime(); |
|
CString timeStamp = currentTime.getCString(); |
|
// |
|
// Allocate completeMessage. |
|
// Needs to be updated if additional info is added |
|
// |
| |
// Check if the file can be opened in append mode |
// Construct the message header |
if (traceFile) |
// The message header is in the following format |
|
// timestamp: <component name> [file name:line number] |
|
if (*message != '\0') |
{ | { |
outFile.open(traceFile,ofstream::app); |
// << 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) ]; |
| |
if (outFile.good()) |
sprintf(completeMessage, "%s: %s %s%s", (const char*)timeStamp, |
|
TRACE_COMPONENT_LIST[traceComponent], message, cstring); |
|
} |
|
else |
{ | { |
_getInstance()->_traceHandler->setFileName (traceFile); |
// |
outFile.close(); |
// 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]; |
|
sprintf(tmpBuffer, "[%u:%s]: ", |
|
System::getPID(), Threads::id().buffer); |
|
|
|
completeMessage = new char[strlen(timeStamp) + |
|
strlen(TRACE_COMPONENT_LIST[traceComponent]) + |
|
strlen(tmpBuffer) + 1 + 5 + |
|
strlen(cstring)]; |
|
|
|
sprintf(completeMessage, "%s: %s %s %s", (const char*)timeStamp, |
|
TRACE_COMPONENT_LIST[traceComponent], tmpBuffer, cstring); |
|
delete [] tmpBuffer; |
|
} |
|
|
|
// Call trace file handler to write message |
|
_getInstance()->_traceHandler->handleMessage(completeMessage); |
|
|
|
delete [] completeMessage; |
|
} |
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////////// |
|
//Validate the trace file |
|
//////////////////////////////////////////////////////////////////////////////// |
|
Boolean Tracer::isValidFileName(const char* filePath) |
|
{ |
|
String moduleName = _getInstance()->_moduleName; |
|
if (moduleName == String::EMPTY) |
|
{ |
|
return _getInstance()->_traceHandler->isValidFilePath(filePath); |
} | } |
else | else |
{ | { |
outFile.close(); |
String extendedFilePath = String(filePath) + "." + moduleName; |
retCode = 1; |
return _getInstance()->_traceHandler->isValidFilePath( |
|
extendedFilePath.getCString()); |
|
} |
|
} |
|
|
|
//////////////////////////////////////////////////////////////////////////////// |
|
//Validate the trace components |
|
//////////////////////////////////////////////////////////////////////////////// |
|
Boolean Tracer::isValidComponents(const String& traceComponents) |
|
{ |
|
String invalidComponents; |
|
return isValidComponents(traceComponents, invalidComponents); |
|
} |
|
|
|
Boolean Tracer::isValidComponents( |
|
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 componentStr; |
|
Boolean validComponent=false; |
|
Boolean retCode=true; |
|
|
|
componentStr = traceComponents; |
|
invalidComponents = String::EMPTY; |
|
|
|
if (componentStr != String::EMPTY) |
|
{ |
|
// Check if ALL is specified |
|
if (String::equalNoCase(componentStr,"ALL")) |
|
{ |
|
return _SUCCESS; |
} | } |
|
|
|
// 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 | else |
{ | { |
retCode=1; |
index++; |
|
} |
|
} |
|
|
|
// Remove the searched componentname from the traceComponents |
|
componentStr.remove(0,position+1); |
|
|
|
if (!validComponent) |
|
{ |
|
invalidComponents.append(componentName); |
|
invalidComponents.append(_COMPONENT_SEPARATOR); |
|
} |
|
} |
|
} |
|
else |
|
{ |
|
// 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; | 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. 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 |
|
|
|
//////////////////////////////////////////////////////////////////////////////// |
|
//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 | //Set the trace level |
//////////////////////////////////////////////////////////////////////////////// | //////////////////////////////////////////////////////////////////////////////// |
Uint32 Tracer::setTraceLevel(const Uint32 traceLevel) | Uint32 Tracer::setTraceLevel(const Uint32 traceLevel) |
|
|
| |
//////////////////////////////////////////////////////////////////////////////// | //////////////////////////////////////////////////////////////////////////////// |
//Set components to be traced. | //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 position=0; |
Uint32 index=0; | Uint32 index=0; |
String componentName; | String componentName; |
|
String componentStr = traceComponents; |
|
String invalidComponents; |
| |
if (traceComponents != String::EMPTY) |
if (componentStr != String::EMPTY) |
{ | { |
// Check if ALL is specified | // Check if ALL is specified |
if (traceComponents == "ALL") |
if (String::equalNoCase(componentStr,"ALL")) |
|
{ |
|
for (index = 0; index < _NUM_COMPONENTS; index++) |
{ | { |
for (int index=0; index < _NUM_COMPONENTS; |
(_getInstance()->_traceComponentMask.get())[index] = true; |
_getInstance()->_traceComponentMask[index++] = true); |
} |
|
_traceOn = true; |
return; | return; |
} | } |
| |
// initialise ComponentMask array to False |
// initialize ComponentMask array to False |
for (int index = 0;index < _NUM_COMPONENTS; |
for (index = 0; index < _NUM_COMPONENTS; index++) |
_getInstance()->_traceComponentMask[index++] = false); |
{ |
|
(_getInstance()->_traceComponentMask.get())[index] = false; |
|
} |
|
_traceOn = false; |
| |
// Append _COMPONENT_SEPARATOR to the end of the traceComponents | // 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. | // Get the Component name from traceComponents. |
// Components are separated by _COMPONENT_SEPARATOR | // 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 | // Lookup the index for Component name in TRACE_COMPONENT_LIST |
index = 0; | index = 0; |
while (index < _NUM_COMPONENTS) | 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 | // Found component, break from the loop |
break; | break; |
|
|
} | } |
| |
// Remove the searched componentname from the traceComponents | // Remove the searched componentname from the traceComponents |
traceComponents.remove(0,position+1); |
componentStr.remove(0,position+1); |
} | } |
} | } |
else | else |
{ | { |
// initialise ComponentMask array to False | // initialise ComponentMask array to False |
for (int index = 0;index < _NUM_COMPONENTS; |
for (Uint32 index = 0;index < _NUM_COMPONENTS; index++) |
_getInstance()->_traceComponentMask[index++] = false); |
{ |
|
(_getInstance()->_traceComponentMask.get())[index] = false; |
} | } |
|
_traceOn = 0; |
|
} |
|
return ; |
|
} |
|
|
|
void Tracer::traceEnter( |
|
TracerToken& token, |
|
const char* file, |
|
size_t line, |
|
Uint32 traceComponent, |
|
const char* method) |
|
{ |
|
token.component = traceComponent; |
|
token.method = method; |
|
|
|
if (isTraceEnabled(traceComponent, LEVEL1)) |
|
{ |
|
_traceMethod( |
|
file, (Uint32)line, traceComponent, |
|
_METHOD_ENTER_MSG, method); |
|
} |
|
} |
|
|
|
void Tracer::traceExit( |
|
TracerToken& token, |
|
const char* file, |
|
size_t line) |
|
{ |
|
if (isTraceEnabled(token.component, LEVEL1) && token.method) |
|
_traceMethod( |
|
file, (Uint32)line, token.component, |
|
_METHOD_EXIT_MSG, token.method); |
} | } |
| |
//////////////////////////////////////////////////////////////////////////////// | //////////////////////////////////////////////////////////////////////////////// |
//Returns the Singleton instance of the Tracer |
//Traces the given string - Overloaded to include the fileName and line number |
|
//of trace origin. |
//////////////////////////////////////////////////////////////////////////////// | //////////////////////////////////////////////////////////////////////////////// |
Tracer* Tracer::_getInstance() |
void Tracer::traceCString( |
|
const char* fileName, |
|
const Uint32 lineNum, |
|
const Uint32 traceComponent, |
|
const char* cstring) |
{ | { |
if (_tracerInstance == 0) |
char* message; |
|
|
|
// |
|
// 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, |
|
"[%d:%s:%s:%u]: ", |
|
System::getPID(), |
|
Threads::id().buffer, |
|
fileName, |
|
lineNum); |
|
|
|
_traceCString(traceComponent, message, cstring); |
|
delete [] message; |
|
} |
|
|
|
void Tracer::traceCIMException( |
|
const Uint32 traceComponent, |
|
const Uint32 traceLevel, |
|
const CIMException& cimException) |
{ | { |
_tracerInstance = new Tracer(); |
PEGASUS_ASSERT(traceLevel != LEVEL1); |
|
if (isTraceEnabled(traceComponent, traceLevel)) |
|
{ |
|
_traceCIMException(traceComponent, cimException); |
} | } |
return _tracerInstance; |
|
} | } |
| |
|
#endif /* !PEGASUS_REMOVE_TRACE */ |
|
|
PEGASUS_NAMESPACE_END | PEGASUS_NAMESPACE_END |