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.25 and 1.62

version 1.25, 2003/03/04 17:40:58

version 1.62, 2008/08/12 18:26:27

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

// Modified By: Dave Rosckes (IBM)

// rosckes@us.ibm.com

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

#include <iostream>

#include <fstream>

#include <cstring>

#include "Logger.h"

#include <Pegasus/Common/Logger.h>

#include "System.h"

#include <Pegasus/Common/Tracer.h>

#include "Destroyer.h"

#include <Pegasus/Common/System.h>

#include <Pegasus/Common/FileSystem.h>

#include <Pegasus/Common/MessageLoader.h>

#include <Pegasus/Common/Executor.h>

#include <Pegasus/Common/Mutex.h>

#if defined(PEGASUS_OS_HPUX) || defined(PEGASUS_PLATFORM_LINUX_IA64_GNU)

#if defined(PEGASUS_USE_SYSLOGS)

#include <syslog.h>

#endif

#ifdef PEGASUS_OS_OS400

#include "qycmmsgclsMessage.H" // ycmMessage class

#endif

PEGASUS_USING_STD;

PEGASUS_NAMESPACE_BEGIN

// Maximum logfile size is defined as 32 MB = 32 * 1024 * 1024

# define PEGASUS_MAX_LOGFILE_SIZE 0X2000000

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

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

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

Uint32 Logger::_severityMask;

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

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

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

// LoggerRep

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

#if defined(PEGASUS_USE_SYSLOGS)

mask for level of severity are all driven from configuration

input.

class LoggerRep

{

static CString _allocLogFileName(

public:

const String& homeDirectory,

Logger::LogFileType logFileType)

LoggerRep(const String& homeDirectory)

{

# ifdef PEGASUS_OS_ZOS

logIdentity = strdup(System::CIMSERVER.getCString());

// If System Log is used open it

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

# endif

}

~LoggerRep()

{

# ifdef PEGASUS_OS_ZOS

System::closelog();

free(logIdentity);

# endif

}

// Actual logging is done in this routine

void log(Logger::LogFileType logFileType,

const String& systemId,

Uint32 logLevel,

const String localizedMsg)

{

// Log the message

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

}

private:

# ifdef PEGASUS_OS_ZOS

char* logIdentity;

# endif

};

#else // !defined(PEGASUS_USE_SYSLOGS)

static const char* fileNames[] =

{

"PegasusTrace.log",

"PegasusStandard.log",

"PegasusError.log",

"PegasusAudit.log",

"PegasusDebug.log"

"PegasusError.log"

};

static const char* lockFileName = "PegasusLog.lock";

int index = int(logFileType);

_constructFileName builds the absolute file name from homeDirectory

if (index > Logger::NUM_LOGS)

and fileName.

index = Logger::ERROR_LOG;

static CString _constructFileName(

const char* logFileName = fileNames[index];

const String& homeDirectory,

const char * fileName)

{

String result;

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

result.reserveCapacity(

(Uint32)(homeDirectory.size() + 1 + strlen(fileName)));

result.append(homeDirectory);

result.append('/');

result.append(logFileName);

result.append(fileName);

return result.getCString();

}

Line 105

Line 155

LoggerRep(const String& homeDirectory)

{

#if !defined(PEGASUS_OS_HPUX) && !defined(PEGASUS_PLATFORM_LINUX_IA64_GNU)

// Add test for home directory set.

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

Line 117

Line 166

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

cerr << "Logging Disabled";

{

MessageLoaderParms parms("Common.Logger.LOGGING_DISABLED",

"Logging Disabled");

cerr << MessageLoader::getMessage(parms);

}

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

//Filelocks are not used for VMS

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

# if !defined(PEGASUS_OS_VMS)

_loggerLockFileName = _constructFileName(homeDirectory, lockFileName);

// Open and close a file to make sure that the file exists, on which

// file lock is requested

FILE *fileLockFilePointer;

fileLockFilePointer = fopen(_loggerLockFileName, "a+");

if(fileLockFilePointer)

{

fclose(fileLockFilePointer);

}

# endif

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

_logFileNames[Logger::TRACE_LOG] = _constructFileName(homeDirectory,

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

fileNames[Logger::TRACE_LOG]);

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

_logFileNames[Logger::STANDARD_LOG] = _constructFileName(homeDirectory,

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

fileNames[Logger::STANDARD_LOG]);

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

# ifdef PEGASUS_ENABLE_AUDIT_LOGGER

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

_logFileNames[Logger::AUDIT_LOG] = _constructFileName(homeDirectory,

fileNames[Logger::AUDIT_LOG]);

#endif

_logFileNames[Logger::ERROR_LOG] = _constructFileName(homeDirectory,

fileNames[Logger::ERROR_LOG]);

}

ostream& logOf(Logger::LogFileType logFileType)

~LoggerRep()

{

int index = int(logFileType);

}

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

// Actual logging is done in this routine

index = Logger::ERROR_LOG;

void log(Logger::LogFileType logFileType,

const String& systemId,

Uint32 logLevel,

const String localizedMsg)

{

// Prepend the systemId to the incoming message

String messageString(systemId);

messageString.append(": ");

messageString.append(localizedMsg); // l10n

return _logs[index];

// Get the logLevel String

// This converts bitmap to string based on highest order

// bit set

// ATTN: KS Fix this more efficiently.

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

# ifndef PEGASUS_OS_VMS

// Acquire AutoMutex (for thread sync)

// and AutoFileLock (for Process Sync).

AutoMutex am(_mutex);

AutoFileLock fileLock(_loggerLockFileName);

Uint32 logFileSize = 0;

// Read logFileSize to check if the logfile needs to be pruned.

FileSystem::getFileSize(String(_logFileNames[logFileType]),

logFileSize);

// Check if the size of the logfile is exceeding 32MB.

if ( logFileSize > PEGASUS_MAX_LOGFILE_SIZE)

{

// Prepare appropriate file name based on the logFileType.

// Eg: if Logfile name is PegasusStandard.log, pruned logfile name

// will be PegasusStandard-062607-122302.log,where 062607-122302

// is the time stamp.

String prunedLogfile(_logFileNames[logFileType],

(Uint32)strlen(_logFileNames[logFileType]) - 4);

prunedLogfile.append('-');

// Get timestamp,remove illegal chars in file name'/' and ':'

// (: is illegal Open VMS) from the time stamp. Append the time

// info to the file name.

String timeStamp = System::getCurrentASCIITime();

for (unsigned int i=0; i<=timeStamp.size(); i++)

{

if(timeStamp[i] == '/' || timeStamp[i] == ':')

{

timeStamp.remove(i, 1);

}

prunedLogfile.append(timeStamp);

// Append '.log' to the file

prunedLogfile.append( ".log");

// Rename the logfile

FileSystem::renameFile(String(_logFileNames[logFileType]),

prunedLogfile);

} // Check if the logfile needs to be pruned.

# endif // ifndef PEGASUS_OS_VMS

// Open Logfile. Based on the value of logFileType, one of the five

// Logfiles will be opened.

ofstream logFileStream;

logFileStream.open(_logFileNames[logFileType], ios::app);

logFileStream << System::getCurrentASCIITime()

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

logFileStream.close();

}

private:

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

CString _logFileNames[int(Logger::NUM_LOGS)];

# ifndef PEGASUS_OS_VMS

CString _loggerLockFileName;

Mutex _mutex;

# endif

};

void Logger::put(

#endif // !defined(PEGASUS_USE_SYSLOGS)

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

// Logger

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

void Logger::_putInternal(

LogFileType logFileType,

const String& systemId,

Uint32 severity,

const Uint32 logComponent, // FUTURE: Support logComponent mask

Uint32 logLevel,

const String& formatString,

const char* messageId,

const Formatter::Arg& arg0,

const Formatter::Arg& arg1,

const Formatter::Arg& arg2,

Line 165

Line 321

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

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

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)

{

// 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_OS_HPUX) || defined(PEGASUS_PLATFORM_LINUX_IA64_GNU)

// Call the actual logging routine is in LoggerRep.

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

_rep->log(logFileType, systemId, logLevel, localizedMsg);

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

// route log message to trace too -> component LogMessages

syslog(syslogLevel, "%s", (const char*)logMsg.getCString());

if (Logger::TRACE_LOG != logFileType)

{

// do not write log message to trace when trace facility is

// the log to avoid double messages

if (Tracer::TRACE_FACILITY_LOG != Tracer::getTraceFacility())

{

PEG_TRACE_CSTRING(

TRC_LOGMSG,

Tracer::LEVEL1,

(const char*) localizedMsg.getCString());

}

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

// 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, 0, arg0, arg1, arg2, arg3,

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

}

// Close the syslog.

void Logger::put(

closelog();

LogFileType logFileType,

const String& systemId,

Uint32 logLevel,

const String& formatString)

{

if (wouldLog(logLevel))

{

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

formatString, 0);

}

#elif defined(PEGASUS_OS_OS400)

void Logger::put(

LogFileType logFileType,

const String& systemId,

Uint32 logLevel,

const String& formatString,

const Formatter::Arg& arg0)

{

if (wouldLog(logLevel))

{

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

formatString, 0, arg0);

}

std::string replacementData = (const char*)logMsg.getCString();

void Logger::put(

// All messages will go to the joblog. In the future

LogFileType logFileType,

// some messages may go to other message queues yet

const String& systemId,

// to be determined.

Uint32 logLevel,

if ((severity & Logger::TRACE) ||

const String& formatString,

(severity & Logger::INFORMATION))

const Formatter::Arg& arg0,

const Formatter::Arg& arg1)

{

if (wouldLog(logLevel))

{

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

formatString, 0, arg0, arg1);

}

// turn into ycmMessage so we can put it in the job log

void Logger::put(

ycmMessage theMessage(msgCPxDF80,

LogFileType logFileType,

CPIprefix,

const String& systemId,

replacementData,

Uint32 logLevel,

"Logger",ycmCTLCIMID);

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, 0, arg0, arg1, arg2);

}

// put the message in the joblog

void Logger::put_l(

theMessage.joblogIt(UnitOfWorkError,

LogFileType logFileType,

ycmMessage::Informational);

const String& systemId,

Uint32 logLevel,

const char* messageId,

const char* 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);

}

if ((severity & Logger::WARNING) ||

void Logger::put_l(

(severity & Logger::SEVERE) ||

LogFileType logFileType,

(severity & Logger::FATAL))

const String& systemId,

Uint32 logLevel,

const char* messageId,

const char* formatString)

{

if (wouldLog(logLevel))

{

// turn into ycmMessage so we can put it in the job log

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

ycmMessage theMessage(msgCPxDF82,

formatString, messageId);

CPDprefix,

}

replacementData,

}

"Logger",ycmCTLCIMID);

// put the message in the joblog

void Logger::put_l(

theMessage.joblogIt(UnitOfWorkError,

LogFileType logFileType,

ycmMessage::Diagnostic);

const String& systemId,

Uint32 logLevel,

const char* messageId,

const char* formatString,

const Formatter::Arg& arg0)

{

if (wouldLog(logLevel))

{

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

formatString, messageId, arg0);

}

#else

void Logger::put_l(

const char* tmp = "";

LogFileType logFileType,

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

const String& systemId,

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

Uint32 logLevel,

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

const char* messageId,

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

const char* formatString,

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

const Formatter::Arg& arg0,

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

const Formatter::Arg& arg1)

<< " " << tmp << logMsg << endl;

{

#endif

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

const char* 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::clean(const String& directory)

void Logger::trace(

LogFileType logFileType,

const String& systemId,

const Uint32 logComponent,

const String& message)

{

//String logFiles = logsDirectory;

if (wouldLog(Logger::TRACE))

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

{

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

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

//System::removeFile(logFiles.getCString());

message, 0);

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

}

//(

//_allocateLogFileName(directory, i)

//removeFile(

//}

}

void Logger::setHomeDirectory(const String& homeDirectory)

Line 281

Line 572

_homeDirectory = homeDirectory;

}

void Logger::setlogLevelMask( const String logLevelList )

{

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;

}

Executor::updateLogLevel(logLevelName.getCString());

}

else

{

// Property logLevel not specified, set default value.

_severityMask = ~Logger::TRACE;

Executor::updateLogLevel("INFORMATION");

}

Boolean Logger::isValidlogLevel(const String logLevel)

{

// Validate the logLevel and modify the logLevel argument

// to reflect the invalid logLevel

Uint32 index=0;

String logLevelName = String::EMPTY;

Boolean validlogLevel=false;

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

}

return validlogLevel;

}

PEGASUS_NAMESPACE_END

Legend:

Removed from v.1.25
changed lines
	Added in v.1.62

No CVS admin address has been configured