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.40.4.2 and 1.71.10.1

version 1.40.4.2, 2007/05/25 17:39:01

version 1.71.10.1, 2013/07/30 05:38:50

Line 1

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

//%LICENSE////////////////////////////////////////////////////////////////

// Licensed to The Open Group (TOG) under one or more contributor license

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

// agreements. Refer to the OpenPegasusNOTICE.txt file distributed with

// this work for additional information regarding copyright ownership.

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

// Each contributor licenses this file to you under the OpenPegasus Open

// Source License; you may not use this file except in compliance with the

// IBM Corp.; EMC Corporation; VERITAS Software Corporation; The Open Group.

// License.

// EMC Corporation; VERITAS Software 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"),

// EMC Corporation; Symantec Corporation; The Open Group.

// to deal in the Software without restriction, including without limitation

// the rights to use, copy, modify, merge, publish, distribute, sublicense,

// Permission is hereby granted, free of charge, to any person obtaining a copy

// and/or sell copies of the Software, and to permit persons to whom the

// of this software and associated documentation files (the "Software"), to

// Software is furnished to do so, subject to the following conditions:

// deal in the Software without restriction, including without limitation the

// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or

// The above copyright notice and this permission notice shall be included

// sell copies of the Software, and to permit persons to whom the Software is

// in all copies or substantial portions of the Software.

// furnished to do so, subject to the following conditions:

// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS

// THE ABOVE COPYRIGHT NOTICE AND THIS PERMISSION NOTICE SHALL BE INCLUDED IN

// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF

// ALL COPIES OR SUBSTANTIAL PORTIONS OF THE SOFTWARE. THE SOFTWARE IS PROVIDED

// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.

// "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT

// IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY

// LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR

// CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,

// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT

// TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE

// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN

// SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

// ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION

// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

//==============================================================================

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

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

#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");

char const* Tracer::TRACE_COMPONENT_LIST[] =

{

"Xml",

"XmlIO",

"Http",

"Repository",

"Dispatcher",

"OsAbstraction",

"Config",

"IndicationHandler",

"Authentication",

"Authorization",

"UserManager",

"Shutdown",

"Server",

"IndicationService",

"MessageQueueService",

"ProviderManager",

"ObjectResolution",

"WQL",

"CQL",

"Thread",

"CIMExportRequestDispatcher",

"SSL",

"ControlProvider",

"CIMOMHandle",

"L10N",

"ExportClient",

"Listener",

"DiscardedData",

"ProviderAgent",

"IndicationFormatter",

"StatisticalData",

"CMPIProvider",

"IndicationGeneration",

"IndicationReceipt",

"CMPIProviderInterface",

"WsmServer",

"RsServer",

#ifdef PEGASUS_ENABLE_PROTOCOL_WEB

"WebServer",

#endif

"LogMessages",

"WMIMapperConsumer",

"InternalProvider"

};

// Set the number of defined components

const Uint32 Tracer::_NUM_COMPONENTS =

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

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

// Set component separator

const char Tracer::_COMPONENT_SEPARATOR = ',';

// Set the number of defined components

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;

Line 81

Line 156

// Initialize public indicator of trace state

Boolean Tracer::_traceOn = false;

Uint32 Tracer::_traceLevelMask=0;

Uint64 Tracer::_traceComponentMask=(Uint64)0;

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

// Tracer constructor

Line 88

Line 165

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

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

Tracer::Tracer()

: _traceComponentMask(new Boolean[_NUM_COMPONENTS]),

: _traceMemoryBufferSize(PEGASUS_TRC_DEFAULT_BUFFER_SIZE_KB),

_traceLevelMask(0),

_traceFacility(TRACE_FACILITY_FILE),

_traceHandler(new TraceFileHandler())

_runningOOP(false),

{

_traceHandler(0)

// Initialize ComponentMask array to false

{

for (Uint32 index=0;index < _NUM_COMPONENTS;

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

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

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

// TRACE_COMPONENT_LIST.

PEGASUS_ASSERT(_NUM_COMPONENTS <= 64);

// Instantiate trace handler according to configured facility

_setTraceHandler(_traceFacility);

}

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

Line 102

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 char* fmt,

TraceHandler * oldTrcHandler = _traceHandler;

va_list argList)

switch(traceFacility)

{

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

case TRACE_FACILITY_LOG:

_traceFacility = TRACE_FACILITY_LOG;

_traceHandler = new TraceLogHandler();

break;

case TRACE_FACILITY_MEMORY:

_traceFacility = TRACE_FACILITY_MEMORY;

_traceHandler = new TraceMemoryHandler();

break;

case TRACE_FACILITY_FILE:

default:

_traceFacility = TRACE_FACILITY_FILE;

_traceHandler = new TraceFileHandler();

}

delete oldTrcHandler;

}

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

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

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

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

void Tracer::_trace(

Boolean Tracer::_isValidTraceFile(String fileName)

const char* fileName,

const Uint32 lineNum,

const Uint32 traceComponent,

const char* fmt,

va_list argList)

{

char* message;

// Check if the file path is a directory

FileSystem::translateSlashes(fileName);

// Allocate memory for the message string

if (FileSystem::isDirectory(fileName))

// Needs to be updated if additional info is added

{

return false;

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

_trace(traceComponent, message, fmt, argList);

// Check if the file exists and is writable

delete [] message;

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

}

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

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

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

//of trace origin.

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

void Tracer::_traceCString(

void Tracer::_trace(

const char* fileName,

const Uint32 lineNum,

const Uint32 traceComponent,

const TraceComponentId traceComponent,

const char* cstring)

const char* fmt,

va_list argList)

{

char* message;

// Allocate memory for the message string

// Needs to be updated if additional info is added

Line 166

Line 283

_STRLEN_MAX_UNSIGNED_INT + (_STRLEN_MAX_PID_TID * 2) + 8];

sprintf(

message,

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

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

System::getPID(),

Threads::id().buffer,

fileName,

lineNum);

_traceCString(traceComponent, message, cstring);

_trace(traceComponent, message, fmt, argList);

delete [] message;

}

Line 180

Line 297

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

CString traceMsg = TraceableCIMException(cimException).getTraceDescription().getCString();

CString traceMsg =

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

// trace the string

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

}

char* Tracer::getHTTPRequestMessage(

char* Tracer::_formatHexDump(

char* targetBuffer,

const char * data,

Uint32 size)

{

unsigned char* p = (unsigned char*)data;

unsigned char buf[16];

size_t n = 0;

int len;

for (size_t i = 0, col = 0; i < size; i++)

{

unsigned char c = p[i];

buf[n++] = c;

if (col == 0)

{

len = sprintf(targetBuffer, "%06X ", (unsigned int)i);

targetBuffer+=len;

}

len = sprintf(targetBuffer, "%02X", c);

targetBuffer+=len;

if ( ((col+1) & 3) == 0 )

{

*targetBuffer = ' ';

targetBuffer++;

}

if (col + 1 == sizeof(buf) || i + 1 == size)

{

for (size_t j = col + 1; j < sizeof(buf); j++)

{

targetBuffer[0]=' ';

targetBuffer[1]=' ';

targetBuffer[2]=' ';

targetBuffer += 3;

}

for (size_t j = 0; j < n; j++)

{

c = buf[j];

if (c >= ' ' && c <= '~')

{

*targetBuffer = c;

}

else

{

*targetBuffer = '.';

}

targetBuffer++;

}

*targetBuffer = '\n';

targetBuffer++;

n = 0;

}

if (col + 1 == sizeof(buf))

{

col = 0;

}

else

{

col++;

}

*targetBuffer = '\n';

targetBuffer++;

return targetBuffer;

}

SharedArrayPtr<char> Tracer::traceFormatChars(

const Buffer& data,

bool binary)

{

static char start[]="\n### Begin of binary data\n";

static char end[]="\n### End of binary data\n";

static char msg[] ="\n### Parts of data omitted. Only first 768 bytes and "\

"last 256 bytes shown. For complete information, use traceLevel 5.\n\n";

SharedArrayPtr<char> outputBuffer(

new char[(10*data.size()+sizeof(start)+sizeof(end)+sizeof(msg))]);

char* target = outputBuffer.get();

size_t size = data.size();

if (0 == size)

{

target[0] = 0;

return outputBuffer;

}

if (binary)

{

memcpy(target,&(start[0]),sizeof(start)-1);

target+=sizeof(start)-1;

// If there are more then 1024 bytes of binary data and the trace level

// is not at highest level(5), we only trace part of the data and not

// everything

if ((_traceLevelMask & Tracer::LEVEL5) || (size <= 1024))

{

target=_formatHexDump(target, data.getData(), size);

}

else

{

target=_formatHexDump(target, data.getData(), 768);

memcpy(target, &(msg[0]), sizeof(msg)-1);

target+=sizeof(msg)-1;

target=_formatHexDump(target, &(data.getData()[size-256]), 256);

}

memcpy(target,&(end[0]),sizeof(end));

}

else

{

memcpy(target, data.getData(), size);

target[size] = 0;

}

return outputBuffer;

}

SharedArrayPtr<char> Tracer::getHTTPRequestMessage(

const Buffer& requestMessage)

{

const Uint32 requestSize = requestMessage.size();

// Check if requestMessage contains "application/x-openpegasus"

// and if true format the the requestBuf as HexDump for tracing

// Binary is only possible on localConnect and doesn't have Basic

// authorization for that reason

if (strstr(requestMessage.getData(),"application/x-openpegasus"))

{

return traceFormatChars(requestMessage,true);

}

// Make a copy of the request message.

AutoArrayPtr<char> requestBuf(new char [requestSize + 1]);

SharedArrayPtr<char>

requestBuf(new char [requestSize + 1]);

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

requestBuf.get()[requestSize] = 0;

Line 206

Line 456

char* sep;

const char* line = requestBuf.get();

while ((sep = HTTPMessage::findSeparator(

while ((sep = HTTPMessage::findSeparator(line)) && (line != sep))

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

(line != sep))

{

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

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

Line 218

Line 466

HTTPMessage::skipHeaderWhitespace(line);

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

userpass < sep;

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

*userpass = 'X', userpass++)

{

}

break;

}

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

}

return requestBuf;

return requestBuf.release();

}

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

Line 235

Line 483

void Tracer::_traceMethod(

const char* fileName,

const Uint32 lineNum,

const Uint32 traceComponent,

const TraceComponentId traceComponent,

const char* methodEntryExit,

const char* method)

{

Line 253

Line 501

sprintf(

message,

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

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

System::getPID(),

Threads::id().buffer,

fileName,

Line 265

Line 513

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 306

Line 538

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

Line 577

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

Line 596

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

{

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

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 417

Line 639

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

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 448

Line 669

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 461

Line 682

// Check if ALL is specified

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

{

return _SUCCESS;

return true;

}

// Append _COMPONENT_SEPARATOR to the end of the traceComponents

Line 508

Line 729

else

{

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

return _SUCCESS;

return true;

}

if (invalidComponents != String::EMPTY)

Line 524

Line 745

}

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

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

{

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

{

_getInstance()->_moduleName = moduleName;

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 560

Line 810

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

instance->_traceFile = newTraceFile;

instance->_traceHandler->configurationUpdated();

}

else

{

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

return 1;

return _getInstance()->_traceHandler->setFileName(

extendedTraceFile.getCString());

}

return 0;

}

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

Line 582

Line 843

switch (traceLevel)

{

case LEVEL0:

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

_traceLevelMask = 0x1F;

break;

default:

_getInstance()->_traceLevelMask = 0;

_traceLevelMask = 0x00;

retCode = 1;

}

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

// is not zero, then turn on tracing.

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

return retCode;

}

Line 610

Line 884

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

void Tracer::setTraceComponents(const String& traceComponents)

{

Uint32 position = 0;

Uint32 index = 0;

String componentName = String::EMPTY;

String componentStr = traceComponents;

String invalidComponents = String::EMPTY;

if (componentStr != String::EMPTY)

{

// Check if ALL is specified

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

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

{

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

// initialize ComponentMask bit array to true

{

_traceComponentMask = (Uint64)-1;

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

}

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

_traceOn = true;

// turn on the flag that activates tracing.

_traceOn = (_traceLevelMask != LEVEL0);

return;

}

// initialize ComponentMask array to False

// initialize ComponentMask bit array to false

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

_traceComponentMask = (Uint64)0;

{

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

}

_traceOn = 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 653

Line 926

if (String::equalNoCase(

componentName,TRACE_COMPONENT_LIST[index]))

{

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

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

_traceOn = true;

// Found component, break from the loop

break;

}

Line 664

Line 935

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=((_traceComponentMask!=(Uint64)0)&&(_traceLevelMask!=LEVEL0));

}

else

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

{

// initialise ComponentMask array to False

return _getInstance()->_traceFacility;

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

}

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

// Set the size of the memory trace buffer

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

Boolean Tracer::setTraceMemoryBufferSize(Uint32 bufferSize)

{

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

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;

}

_traceOn = 0;

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;

token.method = method;

if (_isTraceEnabled(traceComponent, LEVEL1))

if (isTraceEnabled(traceComponent, LEVEL5))

{

_traceMethod(

file, (Uint32)line, traceComponent,

Line 704

Line 1040

const char* file,

size_t line)

{

if (_isTraceEnabled(token.component, LEVEL1))

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

_traceMethod(

file, (Uint32)line, token.component,

_METHOD_EXIT_MSG, token.method);

}

void Tracer::trace(

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

const Uint32 traceComponent,

//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 char *fmt,

const CIMException& cimException)

...)

{

PEGASUS_ASSERT(traceLevel != LEVEL1);

if (isTraceEnabled(traceComponent, traceLevel))

if (_isTraceEnabled(traceComponent, traceLevel))

{

va_list argList;

_traceCIMException(traceComponent, cimException);

va_start(argList,fmt);

_trace(traceComponent,fmt,argList);

va_end(argList);

}

void Tracer::trace(

#endif /* !PEGASUS_REMOVE_TRACE */

const char* fileName,

const Uint32 lineNum,

//set the trace file size only when the tracing is on a file

const Uint32 traceComponent,

void Tracer::setMaxTraceFileSize(const String &size)

const Uint32 traceLevel,

const char* fmt,

...)

{

PEGASUS_ASSERT(traceLevel != LEVEL1);

Tracer *inst = _getInstance();

if (_isTraceEnabled(traceComponent, traceLevel))

if ( inst->getTraceFacility() == TRACE_FACILITY_FILE )

{

va_list argList;

Uint32 traceFileSizeKBytes = 0;

tracePropertyToUint32(size, traceFileSizeKBytes);

//Safe to typecast here as we know that handler is of type file

TraceFileHandler *hdlr = (TraceFileHandler*) (inst->_traceHandler);

hdlr->setMaxTraceFileSize(traceFileSizeKBytes*1024);

va_start(argList,fmt);

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

va_end(argList);

}

void Tracer::traceString(

//set the trace file number for rolling only when the tracing is on a file

const char* fileName,

void Tracer::setMaxTraceFileNumber(const String &maxTraceFileNumber)

const Uint32 lineNum,

const Uint32 traceComponent,

const Uint32 traceLevel,

const String& string)

{

PEGASUS_ASSERT(traceLevel != LEVEL1);

Tracer *inst = _getInstance();

if (_isTraceEnabled(traceComponent, traceLevel))

if ( inst->getTraceFacility() == TRACE_FACILITY_FILE )

{

_traceCString(

Uint32 numberOfTraceFiles = 0;

fileName, lineNum, traceComponent, (const char*) string.getCString());

tracePropertyToUint32(maxTraceFileNumber, numberOfTraceFiles);

//Safe to typecast here as we know that handler is of type file

TraceFileHandler *hdlr = (TraceFileHandler*) (inst->_traceHandler);

hdlr->setMaxTraceFileNumber(numberOfTraceFiles);

}

void Tracer::traceCString(

const char* fileName,

// Converts the quantifiable trace proprties string into a Uint32 value.

const Uint32 lineNum,

// It returns false and the bufferSize is set to 0 if the string was not valid.

const Uint32 traceComponent,

const Uint32 traceLevel,

Boolean Tracer::tracePropertyToUint32(

const char* cstring)

const String& traceProperty, Uint32& valueInUint32 )

{

PEGASUS_ASSERT(traceLevel != LEVEL1);

Boolean retCode = false;

if (_isTraceEnabled(traceComponent, traceLevel))

Uint64 uInt64BufferSize;

valueInUint32 = 0;

CString stringBufferSize = traceProperty.getCString();

retCode = StringConversion::decimalStringToUint64(stringBufferSize,

uInt64BufferSize);

if (retCode )

{

_traceCString(

retCode = StringConversion::checkUintBounds(uInt64BufferSize,

fileName, lineNum, traceComponent, cstring);

CIMTYPE_UINT32);

}

void Tracer::traceCIMException(

if (retCode )

const Uint32 traceComponent,

const Uint32 traceLevel,

const CIMException& cimException)

{

PEGASUS_ASSERT(traceLevel != LEVEL1);

valueInUint32 = (Uint32)uInt64BufferSize;

if (_isTraceEnabled(traceComponent, traceLevel))

{

_traceCIMException(traceComponent, cimException);

}

return retCode;

}

#endif /* !PEGASUS_REMOVE_TRACE */

PEGASUS_NAMESPACE_END

Legend:

Removed from v.1.40.4.2
changed lines
	Added in v.1.71.10.1

No CVS admin address has been configured