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.23.2.1 and 1.47

version 1.23.2.1, 2002/10/28 15:43:24

version 1.47, 2006/11/08 20:38:30

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 21

Line 29

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

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

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

// sushma_fernandes@hp.com

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

#include <iostream>

#include <fstream>

#include "System.h"

#include <cstring>

#include "Logger.h"

#include "System.h"

#include "Destroyer.h"

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

#ifdef PEGASUS_OS_HPUX

#if defined(PEGASUS_USE_SYSLOGS)

#include <syslog.h>

#endif

Line 49

Line 52

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 = ".";

// FUTURE-SF-P3-20020517 : This may need to be configurable. At least needs

const Uint32 Logger::_NUM_LOGLEVEL = 5;

// to be set to 0xFF by default always.

Uint32 Logger::_severityMask = 0xFF; // Set all on by default

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

Line 66

Line 85

mask for level of severity are all driven from configuration

input.

static char* _allocLogFileName(

static CString _allocLogFileName(

const String& homeDirectory,

Logger::LogFileType logFileType)

{

Line 74

Line 93

{

"PegasusTrace.log",

"PegasusStandard.log",

"PegasusAudit.log",

"PegasusError.log",

"PegasusDebug.log"

};

Line 87

Line 107

String result;

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 99

Line 119

LoggerRep(const String& homeDirectory)

{

#ifndef PEGASUS_OS_HPUX

#if !defined(PEGASUS_USE_SYSLOGS)

// Add test for home directory set.

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

char* lgDir = homeDirectory.allocateCString();

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

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

cout << "Logging Disabled";

//l10n

delete [] lgDir;

//cerr << "Logging Disabled";

MessageLoaderParms parms("Common.Logger.LOGGING_DISABLED",

"Logging Disabled");

cerr << MessageLoader::getMessage(parms);

}

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

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;

#ifndef PEGASUS_DISABLE_AUDIT_LOGGER

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

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

#endif

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

delete [] fileName;

#else

#ifdef PEGASUS_OS_ZOS

logIdendity = System::CIMSERVER.getCString();

// If System Log is used open it

System::openlog(logIdendity, LOG_PID, LOG_DAEMON);

#endif

}

~LoggerRep()

{

#if !defined(PEGASUS_USE_SYSLOGS)

_logs[Logger::TRACE_LOG].close();

_logs[Logger::STANDARD_LOG].close();

#ifndef PEGASUS_DISABLE_AUDIT_LOGGER

_logs[Logger::AUDIT_LOG].close();

#endif

_logs[Logger::ERROR_LOG].close();

_logs[Logger::DEBUG_LOG].close();

#else

#ifdef PEGASUS_OS_ZOS

System::closelog();

#endif

}

Line 138

Line 195

{

int index = int(logFileType);

if (index > int(Logger::ERROR_LOG))

if (index > int(Logger::NUM_LOGS))

index = Logger::ERROR_LOG;

return _logs[index];

Line 146

Line 203

private:

#ifdef PEGASUS_OS_ZOS

CString logIdendity;

#endif

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

};

void Logger::put(

void Logger::_putInternal(

LogFileType logFileType,

const String& systemId,

Uint32 severity,

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 165

Line 227

const Formatter::Arg& arg8,

const Formatter::Arg& arg9)

{

// Test for severity against severity mask to determine

// Test for logLevel against severity mask to determine

// if we write this log.

if ((_severityMask & severity) != 0)

if ((_severityMask & logLevel) != 0)

{

if (!_rep)

_rep = new LoggerRep(_homeDirectory);

// Get the Severity String

// Get the logLevel String

// This converts bitmap to string based on highest order

// bit set

// ATTN: KS Fix this more efficiently.

Line 187

Line 249

// NUM_LEVELS = 5

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

String logMsg = Formatter::format(formatString,

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

ArrayDestroyer<char> logMsgCString(logMsg.allocateCString());

}

// l10n end

#ifdef PEGASUS_OS_HPUX

#if defined(PEGASUS_USE_SYSLOGS)

// FUTURE-SF-P3-20020517 : Use the Syslog on HP-UX. Eventually only

// certain messages will go to the Syslog and others to the

// Pegasus Logger.

Uint32 syslogLevel = LOG_DEBUG;

// Map the log levels.

if (severity & Logger::TRACE) syslogLevel = LOG_DEBUG;

if (severity & Logger::INFORMATION) syslogLevel = LOG_INFO;

if (severity & Logger::WARNING) syslogLevel = LOG_WARNING;

if (severity & Logger::SEVERE) syslogLevel = LOG_ERR;

if (severity & Logger::FATAL) syslogLevel = LOG_CRIT;

// Open the syslog.

// Ignore the systemId and open the log as cimserver

openlog("cimserver", LOG_PID|LOG_CONS, LOG_DAEMON);

// Log the message

syslog(syslogLevel, "%s", logMsgCString.getPointer());

System::syslog(systemId, logLevel, localizedMsg.getCString());

// Close the syslog.

closelog();

#else

// Prepend the systemId to the incoming message

String messageString(systemId);

messageString.append(": ");

messageString.append(localizedMsg); // l10n

const char* tmp = "";

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

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

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

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

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

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

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

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

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

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

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

<< " " << tmp << logMsgCString.getPointer() << endl;

<< " " << tmp << (const char *)messageString.getCString() << endl;

#endif

}

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

// Public methods start here:

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

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)

{

if (wouldLog(logLevel))

{

Logger::_putInternal(logFileType, systemId, 0, logLevel,

formatString, String::EMPTY, arg0, arg1, arg2, arg3,

arg4, arg5, arg6, arg7, arg8, arg9);

}

void Logger::clean(const String& directory)

void Logger::put(

LogFileType logFileType,

const String& systemId,

Uint32 logLevel,

const String& formatString)

{

if (wouldLog(logLevel))

{

//String logFiles = logsDirectory;

Logger::_putInternal(logFileType, systemId, 0, logLevel,

//logFiles.append("/PegasusTrace.log");

formatString, String::EMPTY);

//char* lgFiles = logFiles.allocateCString();

}

//cout << "Delete logs in " << logFiles << endl;

}

//System::removeFile(lgFiles);

//delete [] lgFiles;

void Logger::put(

//for (i = xx; i < yy; i++)

LogFileType logFileType,

//(

const String& systemId,

//_allocateLogFileName(directory, i)

Uint32 logLevel,

//removeFile(

const String& formatString,

//}

const Formatter::Arg& arg0)

{

if (wouldLog(logLevel))

{

Logger::_putInternal(logFileType, systemId, 0, logLevel,

formatString, String::EMPTY, arg0);

}

void Logger::put(

LogFileType logFileType,

const String& systemId,

Uint32 logLevel,

const String& formatString,

const Formatter::Arg& arg0,

const Formatter::Arg& arg1)

{

if (wouldLog(logLevel))

{

Logger::_putInternal(logFileType, systemId, 0, logLevel,

formatString, String::EMPTY, arg0, arg1);

}

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)

{

if (wouldLog(logLevel))

{

Logger::_putInternal(logFileType, systemId, 0, logLevel,

formatString, String::EMPTY, arg0, arg1, arg2);

}

void Logger::put_l(

LogFileType logFileType,

const String& systemId,

Uint32 logLevel,

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)

{

if (wouldLog(logLevel))

{

Logger::_putInternal(logFileType, systemId, 0, logLevel,

formatString, messageId, arg0, arg1, arg2, arg3, arg4, arg5,

arg6, arg7, arg8, arg9);

}

void Logger::put_l(

LogFileType logFileType,

const String& systemId,

Uint32 logLevel,

const String& messageId,

const String& formatString)

{

if (wouldLog(logLevel))

{

Logger::_putInternal(logFileType, systemId, 0, logLevel,

formatString, messageId);

}

void Logger::put_l(

LogFileType logFileType,

const String& systemId,

Uint32 logLevel,

const String& messageId,

const String& formatString,

const Formatter::Arg& arg0)

{

if (wouldLog(logLevel))

{

Logger::_putInternal(logFileType, systemId, 0, logLevel,

formatString, messageId, arg0);

}

void Logger::put_l(

LogFileType logFileType,

const String& systemId,

Uint32 logLevel,

const String& messageId,

const String& formatString,

const Formatter::Arg& arg0,

const Formatter::Arg& arg1)

{

if (wouldLog(logLevel))

{

Logger::_putInternal(logFileType, systemId, 0, logLevel,

formatString, messageId, arg0, arg1);

}

void Logger::put_l(

LogFileType logFileType,

const String& systemId,

Uint32 logLevel,

const String& messageId,

const String& formatString,

const Formatter::Arg& arg0,

const Formatter::Arg& arg1,

const Formatter::Arg& arg2)

{

if (wouldLog(logLevel))

{

Logger::_putInternal(logFileType, systemId, 0, logLevel,

formatString, messageId, arg0, arg1, arg2);

}

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)

{

if (wouldLog(Logger::TRACE))

{

Logger::_putInternal(logFileType, systemId, logComponent, Logger::TRACE,

formatString, String::EMPTY, arg0, arg1, arg2, arg3, arg4, arg5,

arg6, arg7, arg8, arg9);

}

void Logger::trace(

LogFileType logFileType,

const String& systemId,

const Uint32 logComponent,

const String& formatString)

{

if (wouldLog(Logger::TRACE))

{

Logger::_putInternal(logFileType, systemId, logComponent, Logger::TRACE,

formatString, String::EMPTY);

}

void Logger::trace(

LogFileType logFileType,

const String& systemId,

const Uint32 logComponent,

const String& formatString,

const Formatter::Arg& arg0)

{

if (wouldLog(Logger::TRACE))

{

Logger::_putInternal(logFileType, systemId, logComponent, Logger::TRACE,

formatString, String::EMPTY, arg0);

}

void Logger::trace(

LogFileType logFileType,

const String& systemId,

const Uint32 logComponent,

const String& formatString,

const Formatter::Arg& arg0,

const Formatter::Arg& arg1)

{

if (wouldLog(Logger::TRACE))

{

Logger::_putInternal(logFileType, systemId, logComponent, Logger::TRACE,

formatString, String::EMPTY, arg0, arg1);

}

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)

{

if (wouldLog(Logger::TRACE))

{

Logger::_putInternal(logFileType, systemId, logComponent, Logger::TRACE,

formatString, String::EMPTY, arg0, arg1, arg2);

}

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)

{

if (wouldLog(Logger::TRACE))

{

Logger::_putInternal(logFileType, systemId, logComponent, Logger::TRACE,

formatString, messageId, arg0, arg1, arg2, arg3, arg4, arg5, arg6,

arg7, arg8, arg9);

}

void Logger::trace_l(

LogFileType logFileType,

const String& systemId,

const Uint32 logComponent,

const String& messageId,

const String& formatString)

{

if (wouldLog(Logger::TRACE))

{

Logger::_putInternal(logFileType, systemId, logComponent, Logger::TRACE,

formatString, messageId);

}

void Logger::trace_l(

LogFileType logFileType,

const String& systemId,

const Uint32 logComponent,

const String& messageId,

const String& formatString,

const Formatter::Arg& arg0)

{

if (wouldLog(Logger::TRACE))

{

Logger::_putInternal(logFileType, systemId, logComponent, Logger::TRACE,

formatString, messageId, arg0);

}

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)

{

if (wouldLog(Logger::TRACE))

{

Logger::_putInternal(logFileType, systemId, logComponent, Logger::TRACE,

formatString, messageId, arg0, arg1);

}

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)

{

if (wouldLog(Logger::TRACE))

{

Logger::_putInternal(logFileType, systemId, logComponent, Logger::TRACE,

formatString, messageId, arg0, arg1, arg2);

}

void Logger::setHomeDirectory(const String& homeDirectory)

Line 247

Line 655

_homeDirectory = homeDirectory;

}

void Logger::setlogLevelMask( const String logLevelList )

{

Uint32 position = 0;

Uint32 logLevelType = 0;

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.23.2.1
changed lines
	Added in v.1.47

No CVS admin address has been configured