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.53 and 1.71

version 1.53, 2007/05/28 10:24:38

version 1.71, 2013/04/09 05:53:13

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.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN 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 <iostream>

#include <fstream>

#include <cstring>

#include "Logger.h"

#include <Pegasus/Common/Logger.h>

#include "System.h"

#include <Pegasus/Common/Tracer.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_USE_SYSLOGS)

# include <syslog.h>

Line 46

Line 48

PEGASUS_NAMESPACE_BEGIN

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

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

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

Line 66

Line 69

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;

// LoggerRep

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

#if defined(PEGASUS_USE_SYSLOGS)

Log organization and names are open.

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

class LoggerRep

mask for level of severity are all driven from configuration

{

input.

public:

static CString _allocLogFileName(

LoggerRep(const String&)

const String& homeDirectory,

{

Logger::LogFileType logFileType)

# 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,

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

"PegasusAudit.log",

"PegasusError.log",

"PegasusError.log"

"PegasusDebug.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((Uint32)(homeDirectory.size() + 1 +

result.reserveCapacity(

strlen(logFileName)));

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

result.append(homeDirectory);

result.append('/');

result.append(logFileName);

result.append(fileName);

return result.getCString();

}

Line 120

Line 152

LoggerRep(const String& homeDirectory)

{

#if !defined(PEGASUS_USE_SYSLOGS)

// Add test for home directory set.

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

Line 139

Line 170

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

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

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

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

// file lock is requested

#ifndef PEGASUS_DISABLE_AUDIT_LOGGER

FILE *fileLockFilePointer;

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

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

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

if(fileLockFilePointer)

{

fclose(fileLockFilePointer);

}

#endif

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

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

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

fileNames[Logger::TRACE_LOG]);

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

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

#else

#ifdef PEGASUS_OS_ZOS

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

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

fileNames[Logger::STANDARD_LOG]);

// If System Log is used open it

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

#endif

# ifdef PEGASUS_ENABLE_AUDIT_LOGGER

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

fileNames[Logger::AUDIT_LOG]);

#endif

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

fileNames[Logger::ERROR_LOG]);

}

~LoggerRep()

{

#if !defined(PEGASUS_USE_SYSLOGS)

}

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

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

#ifndef PEGASUS_DISABLE_AUDIT_LOGGER

// Actual logging is done in this routine

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

void log(Logger::LogFileType logFileType,

#endif

const String& systemId,

Uint32 logLevel,

const String &localizedMsg)

{

// Prepend the systemId to the incoming message

String messageString(systemId);

messageString.append(": ");

messageString.append(localizedMsg); // l10n

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

// Get the logLevel String

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

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

#else

# ifndef PEGASUS_OS_VMS

// Acquire AutoMutex (for thread sync)

// and AutoFileLock (for Process Sync).

AutoMutex am(_mutex);

AutoFileLock fileLock(_loggerLockFileName);

#ifdef PEGASUS_OS_ZOS

Uint32 logFileSize = 0;

System::closelog();

free(logIdentity);

#endif

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

if ( logFileSize > _maxLogFileSizeBytes)

{

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

ostream& logOf(Logger::LogFileType logFileType)

// 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] == ':')

{

int index = int(logFileType);

timeStamp.remove(i, 1);

}

prunedLogfile.append(timeStamp);

// Append '.log' to the file

prunedLogfile.append( ".log");

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

// Rename the logfile

index = Logger::ERROR_LOG;

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

prunedLogfile);

return _logs[index];

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

}

static void setMaxLogFileSize(Uint32 maxLogFileSizeBytes)

{

_maxLogFileSizeBytes = maxLogFileSizeBytes;

}

private:

#ifdef PEGASUS_OS_ZOS

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

char* logIdentity;

static Uint32 _maxLogFileSizeBytes;

# ifndef PEGASUS_OS_VMS

CString _loggerLockFileName;

Mutex _mutex;

#endif

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

};

Uint32 LoggerRep::_maxLogFileSizeBytes;

#endif // !defined(PEGASUS_USE_SYSLOGS)

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

// Logger

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

void Logger::_putInternal(

LogFileType logFileType,

const String& systemId,

const Uint32 logComponent, // FUTURE: Support logComponent mask

Uint32 logLevel,

const String& formatString,

const String& message)

const String& messageId,

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)

{

// Test for logLevel against severity mask to determine

// if we write this log.

if ((_severityMask & logLevel) != 0)

{

if (!_rep)

_rep = new LoggerRep(_homeDirectory);

// Call the actual logging routine is in LoggerRep.

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

// l10n start

// PEP 315

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

// The trace can be routed into the log. The logged trace messages are

String localizedMsg;

// logged with logFileType of Logger::TRACE_LOG.

// To avoid a cirular writing of these messages, log messages with

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

// logFileType of Logger::TRACE_LOG are never send to the trace.

// message in the locale of the server process.

if (Logger::TRACE_LOG != logFileType)

if (messageId != String::EMPTY)

{

// For all other logFileType's send the log messages to the trace.

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

// But do not write log messages to trace when the trace facility is

MessageLoaderParms msgParms(messageId, formatString);

// set to log. This avoids double messages.

msgParms.useProcessLocale = true;

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

msgParms.arg0 = arg0;

{

msgParms.arg1 = arg1;

PEG_TRACE_CSTRING(

msgParms.arg2 = arg2;

TRC_LOGMSG,

msgParms.arg3 = arg3;

Tracer::LEVEL1,

msgParms.arg4 = arg4;

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

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)

// Log the message

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

#else

// Prepend the systemId to the incoming message

String messageString(systemId);

messageString.append(": ");

messageString.append(localizedMsg); // l10n

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

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

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

#endif

}

Line 320

Line 363

{

if (wouldLog(logLevel))

{

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

Logger::_putInternal(logFileType, systemId, logLevel,

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

Formatter::format(formatString, arg0, arg1, arg2, arg3,

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

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

}

Line 334

Line 377

{

if (wouldLog(logLevel))

{

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

Logger::_putInternal(logFileType, systemId, logLevel, formatString);

formatString, String::EMPTY);

}

Line 348

Line 390

{

if (wouldLog(logLevel))

{

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

Logger::_putInternal(logFileType, systemId, logLevel,

formatString, String::EMPTY, arg0);

Formatter::format(formatString, arg0));

}

Line 363

Line 405

{

if (wouldLog(logLevel))

{

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

Logger::_putInternal(logFileType, systemId, logLevel,

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

Formatter::format(formatString, arg0, arg1));

}

Line 379

Line 421

{

if (wouldLog(logLevel))

{

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

Logger::_putInternal(logFileType, systemId, logLevel,

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

Formatter::format(formatString, 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);

}

Line 442

Line 430

LogFileType logFileType,

const String& systemId,

Uint32 logLevel,

const String& messageId,

const MessageLoaderParms& msgParms)

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,

MessageLoaderParms parms = msgParms;

formatString, messageId, arg0, arg1, arg2);

parms.useProcessLocale = true;

}

Logger::_putInternal(logFileType, systemId, logLevel,

}

MessageLoader::getMessage(parms));

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

const String& formatString)

{

if (wouldLog(Logger::TRACE))

{

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

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

formatString, String::EMPTY);

message);

}

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

}

Line 645

Line 458

_homeDirectory = homeDirectory;

}

void Logger::setlogLevelMask( const String logLevelList )

void Logger::setlogLevelMask( const String &logLevelList )

{

Uint32 logLevelType = 0;

String logLevelName = logLevelList;

Line 696

Line 509

case Logger::FATAL:

_severityMask |= Logger::FATAL;

}

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

}

else

{

// Property logLevel not specified, set default value.

_severityMask = ~Logger::TRACE;

Executor::updateLogLevel("INFORMATION");

}

return ;

}

Boolean Logger::isValidlogLevel(const String logLevel)

Boolean Logger::isValidlogLevel(const String &logLevel)

{

// Validate the logLevel and modify the logLevel argument

// to reflect the invalid logLevel

Line 739

Line 554

else

{

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

return _SUCCESS;

return true;

}

return validlogLevel;

}

#if !defined (PEGASUS_USE_SYSLOGS)

void Logger::setMaxLogFileSize(Uint32 maxLogFileSizeBytes)

{

LoggerRep::setMaxLogFileSize(maxLogFileSizeBytes);

}

#endif

PEGASUS_NAMESPACE_END

Legend:

Removed from v.1.53
changed lines
	Added in v.1.71

No CVS admin address has been configured