pegasus/src/Pegasus/Common/Logger.cpp - diff

Return to Logger.cpp CVS log

Up to [Pegasus] / pegasus / src / Pegasus / Common

Diff for /pegasus/src/Pegasus/Common/Logger.cpp between version 1.2 and 1.28.6.3

version 1.2, 2001/04/25 22:20:55

version 1.28.6.3, 2003/08/14 11:55:42

Line 1

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

// The Open Group, Tivoli Systems

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL

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

// THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

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

// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING

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

// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER

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

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

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

// Author: Mike Brasher (mbrasher@bmc.com)

// Modified By:

// Modified By: Sushma Fernandes (Hewlett-Packard Company)

// sushma_fernandes@hp.com

// Modified By: Dave Rosckes (IBM)

// rosckes@us.ibm.com

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

#include <iostream>

#include <fstream>

#include <cstring>

#include "Logger.h"

#include "System.h"

#include "Destroyer.h"

#include <Pegasus/Common/MessageLoader.h> //l10n

using namespace std;

PEGASUS_USING_STD;

PEGASUS_NAMESPACE_BEGIN

const Uint32 Logger::TRACE = (1 << 0);

const Uint32 Logger::INFORMATIVE = (1 << 1);

const Uint32 Logger::INFORMATION = (1 << 1);

const Uint32 Logger::WARNING = (1 << 2);

const Uint32 Logger::SEVERE = (1 << 3);

const Uint32 Logger::FATAL = (1 << 4);

static char const* LOGLEVEL_LIST[] =

{

"TRACE",

"INFORMATION",

"WARNING",

"SEVERE",

"FATAL"

};

LoggerRep* Logger::_rep = 0;

String Logger::_homeDirectory = ".";

static char* _allocLogFileName(

const Uint32 Logger::_NUM_LOGLEVEL = 5;

// Set separator

const char Logger::_SEPARATOR = '@';

Uint32 Logger::_severityMask;

Uint32 Logger::_writeControlMask = 0xF; // Set all on by default

// Set the return codes

const Boolean Logger::_SUCCESS = 1;

const Boolean Logger::_FAILURE = 0;

/* _allocLogFileName. Allocates the name from a name set.

Today this is static. However, it should be completely

configerable and driven from the config file so that

Log organization and names are open.

ATTN: rewrite this so that names, choice to do logs and

mask for level of severity are all driven from configuration

input.

static CString _allocLogFileName(

const String& homeDirectory,

Logger::LogFileType logFileType)

{

static char* fileNames[] =

static const char* fileNames[] =

{

"trace.log",

"PegasusTrace.log",

"standard.log",

"PegasusStandard.log",

"error.log"

"PegasusError.log",

"PegasusDebug.log"

};

int index = int(logFileType);

Line 62

Line 102

const char* logFileName = fileNames[index];

String result;

result.reserve(homeDirectory.getLength() + 1 + strlen(logFileName));

result.reserveCapacity(homeDirectory.size() + 1 + strlen(logFileName));

result += homeDirectory;

result.append(homeDirectory);

result += '/';

result.append('/');

result += logFileName;

result.append(logFileName);

return result.allocateCString();

return result.getCString();

}

class LoggerRep

Line 75

Line 115

LoggerRep(const String& homeDirectory)

{

char* fileName = _allocLogFileName(homeDirectory, Logger::TRACE_LOG);

#if !defined(PEGASUS_USE_SYSLOGS)

// Add test for home directory set.

// If home directory does not exist, create it.

CString lgDir = homeDirectory.getCString();

if (!System::isDirectory(lgDir))

System::makeDirectory(lgDir);

// KS: I put the second test in just in case some trys to create

// a completly erronous directory. At least we will get a message

if (!System::isDirectory(lgDir)){

//l10n

//cerr << "Logging Disabled";

MessageLoaderParms parms("Common.Logger.LOGGING_DISABLED",

"Logging Disabled");

cerr << MessageLoader::getMessage(parms);

}

CString fileName = _allocLogFileName(homeDirectory, Logger::TRACE_LOG);

_logs[Logger::TRACE_LOG].open(fileName, ios::app);

delete [] fileName;

fileName = _allocLogFileName(homeDirectory, Logger::STANDARD_LOG);

_logs[Logger::STANDARD_LOG].open(fileName, ios::app);

delete [] fileName;

fileName = _allocLogFileName(homeDirectory, Logger::ERROR_LOG);

_logs[Logger::ERROR_LOG].open(fileName, ios::app);

delete [] fileName;

fileName = _allocLogFileName(homeDirectory, Logger::DEBUG_LOG);

_logs[Logger::DEBUG_LOG].open(fileName, ios::app);

#endif

}

ostream& logOf(Logger::LogFileType logFileType)

Line 103

Line 165

ofstream _logs[int(Logger::NUM_LOGS)];

};

void Logger::put(

void Logger::_putInternal(

LogFileType logFileType,

const String& systemId,

Uint32 level,

const Uint32 logComponent, // TODO: Support logComponent mask in future release

Uint32 logLevel,

const String& formatString,

const String& messageId, // l10n

const Formatter::Arg& arg0,

const Formatter::Arg& arg1,

const Formatter::Arg& arg2,

Line 119

Line 183

const Formatter::Arg& arg8,

const Formatter::Arg& arg9)

{

// Test for logLevel against severity mask to determine

// if we write this log.

if ((_severityMask & logLevel) != 0)

{

if (!_rep)

_rep = new LoggerRep(_homeDirectory);

_rep->logOf(logFileType) << Formatter::format(formatString,

// Get the logLevel String

arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9) << endl;

// This converts bitmap to string based on highest order

// bit set

// ATTN: KS Fix this more efficiently.

static const char* svNames[] =

{

"TRACE ",

"INFO ",

"WARNING ",

"SEVERE ",

"FATAL "

};

// NUM_LEVELS = 5

int sizeSvNames = sizeof(svNames) / sizeof(svNames[0]) - 1;

// l10n start

// The localized message to be sent to the system log.

String localizedMsg;

// If the caller specified a messageId, then load the localized

// message in the locale of the server process.

if (messageId != String::EMPTY)

{

// A message ID was specified. Use the MessageLoader.

MessageLoaderParms msgParms(messageId, formatString);

msgParms.useProcessLocale = true;

msgParms.arg0 = arg0;

msgParms.arg1 = arg1;

msgParms.arg2 = arg2;

msgParms.arg3 = arg3;

msgParms.arg4 = arg4;

msgParms.arg5 = arg5;

msgParms.arg6 = arg6;

msgParms.arg7 = arg7;

msgParms.arg8 = arg8;

msgParms.arg9 = arg9;

localizedMsg = MessageLoader::getMessage(msgParms);

}

else

{ // No message ID. Use the Pegasus formatter

localizedMsg = Formatter::format(formatString,

arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);

}

// l10n end

#if defined(PEGASUS_USE_SYSLOGS)

// Open the syslog.

// Ignore the systemId and open the log as cimserver

System::openlog(systemId);

// Log the message

System::syslog(logLevel,(const char*)localizedMsg.getCStringUTF8());

// Close the syslog.

System::closelog();

#else

// Prepend the systemId to the incoming message

String messageString(systemId);

messageString.append(": ");

messageString.append(localizedMsg); // l10n

const char* tmp = "";

if (logLevel & Logger::TRACE) tmp = "TRACE ";

if (logLevel & Logger::INFORMATION) tmp = "INFO ";

if (logLevel & Logger::WARNING) tmp = "WARNING ";

if (logLevel & Logger::SEVERE) tmp = "SEVERE ";

if (logLevel & Logger::FATAL) tmp = "FATAL ";

_rep->logOf(logFileType) << System::getCurrentASCIITime()

<< " " << tmp << messageString.getCStringUTF8() << endl;

#endif

}

void Logger::put(

LogFileType logFileType,

const String& systemId,

Uint32 logLevel,

const String& formatString,

const Formatter::Arg& arg0,

const Formatter::Arg& arg1,

const Formatter::Arg& arg2,

const Formatter::Arg& arg3,

const Formatter::Arg& arg4,

const Formatter::Arg& arg5,

const Formatter::Arg& arg6,

const Formatter::Arg& arg7,

const Formatter::Arg& arg8,

const Formatter::Arg& arg9)

{

Uint32 logComponent = 0;

Logger::_putInternal(

logFileType,

systemId,

logComponent,

logLevel,

formatString,

//l10n

String::EMPTY,

arg0,

arg1,

arg2,

arg3,

arg4,

arg5,

arg6,

arg7,

arg8,

arg9);

}

// l10n

void Logger::put_l(

LogFileType logFileType,

const String& systemId,

Uint32 logLevel,

const String& messageId, // l10n

const String& formatString,

const Formatter::Arg& arg0,

const Formatter::Arg& arg1,

const Formatter::Arg& arg2,

const Formatter::Arg& arg3,

const Formatter::Arg& arg4,

const Formatter::Arg& arg5,

const Formatter::Arg& arg6,

const Formatter::Arg& arg7,

const Formatter::Arg& arg8,

const Formatter::Arg& arg9)

{

Uint32 logComponent = 0;

Logger::_putInternal(

logFileType,

systemId,

logComponent,

logLevel,

formatString,

messageId,

arg0,

arg1,

arg2,

arg3,

arg4,

arg5,

arg6,

arg7,

arg8,

arg9);

}

void Logger::trace(

LogFileType logFileType,

const String& systemId,

const Uint32 logComponent,

const String& formatString,

const Formatter::Arg& arg0,

const Formatter::Arg& arg1,

const Formatter::Arg& arg2,

const Formatter::Arg& arg3,

const Formatter::Arg& arg4,

const Formatter::Arg& arg5,

const Formatter::Arg& arg6,

const Formatter::Arg& arg7,

const Formatter::Arg& arg8,

const Formatter::Arg& arg9)

{

Uint32 logLevel = Logger::TRACE;

Logger::_putInternal(

logFileType,

systemId,

logComponent,

logLevel,

formatString,

// l10n

String::EMPTY,

arg0,

arg1,

arg2,

arg3,

arg4,

arg5,

arg6,

arg7,

arg8,

arg9);

}

// l10n

void Logger::trace_l(

LogFileType logFileType,

const String& systemId,

const Uint32 logComponent,

const String& messageId,

const String& formatString,

const Formatter::Arg& arg0,

const Formatter::Arg& arg1,

const Formatter::Arg& arg2,

const Formatter::Arg& arg3,

const Formatter::Arg& arg4,

const Formatter::Arg& arg5,

const Formatter::Arg& arg6,

const Formatter::Arg& arg7,

const Formatter::Arg& arg8,

const Formatter::Arg& arg9)

{

Uint32 logLevel = Logger::TRACE;

Logger::_putInternal(

logFileType,

systemId,

logComponent,

logLevel,

formatString,

messageId,

arg0,

arg1,

arg2,

arg3,

arg4,

arg5,

arg6,

arg7,

arg8,

arg9);

}

void Logger::setHomeDirectory(const String& homeDirectory)

Line 131

Line 427

_homeDirectory = homeDirectory;

}

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

// Set logLevel.

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

void Logger::setlogLevelMask( const String logLevelList )

{

Uint32 position = 0;

Uint32 logLevelType;

String logLevelName = logLevelList;

// Check if logLevel has been specified

if (logLevelName != String::EMPTY)

{

// initialise _severityMask

_severityMask = 0;

// Set logLevelType to indicate the level of logging

// required by the user.

if (String::equalNoCase(logLevelName,"TRACE"))

{

logLevelType = Logger::TRACE;

}

else if (String::equalNoCase(logLevelName,"INFORMATION"))

{

logLevelType = Logger::INFORMATION;

}

else if (String::equalNoCase(logLevelName,"WARNING"))

{

logLevelType = Logger::WARNING;

}

else if (String::equalNoCase(logLevelName,"SEVERE"))

{

logLevelType = Logger::SEVERE;

}

else if (String::equalNoCase(logLevelName,"FATAL"))

{

logLevelType = Logger::FATAL;

}

// Setting _severityMask. NOTE: When adding new logLevels

// it is essential that they are adding in ascending order

// based on priority. Once a case statement is true we will

// continue to set all following log levels with a higher

// priority.

switch(logLevelType)

{

case Logger::TRACE:

_severityMask |= Logger::TRACE;

case Logger::INFORMATION:

_severityMask |= Logger::INFORMATION;

case Logger::WARNING:

_severityMask |= Logger::WARNING;

case Logger::SEVERE:

_severityMask |= Logger::SEVERE;

case Logger::FATAL:

_severityMask |= Logger::FATAL;

}

else

{

// Property logLevel not specified, set default value.

_severityMask = ~Logger::TRACE;

}

return ;

}

Boolean Logger::isValidlogLevel(

const String logLevel)

{

// Validate the logLevel and modify the logLevel argument

// to reflect the invalid logLevel

Uint32 position=0;

Uint32 index=0;

String logLevelName = String::EMPTY;

Boolean validlogLevel=false;

Boolean retCode=true;

logLevelName = logLevel;

if (logLevelName != String::EMPTY)

{

// Lookup the index for logLevel name in _logLevel_LIST

index = 0;

validlogLevel = false;

while (index < _NUM_LOGLEVEL)

{

if (String::equalNoCase(logLevelName, LOGLEVEL_LIST[index]))

{

// Found logLevel, break from the loop

validlogLevel = true;

break;

}

else

{

index++;

}

else

{

// logLevels is empty, it is a valid value so return true

return _SUCCESS;

}

return validlogLevel;

}

PEGASUS_NAMESPACE_END

Legend:

Removed from v.1.2
changed lines
	Added in v.1.28.6.3

No CVS admin address has been configured