265 lines
7.6 KiB
C++
265 lines
7.6 KiB
C++
/*
|
|
* Copyright 2003,2004 The Apache Software Foundation.
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
|
|
#ifndef _LOG4CXX_SPI_LOGGING_EVENT_H
|
|
#define _LOG4CXX_SPI_LOGGING_EVENT_H
|
|
|
|
#include <log4cxx/helpers/objectptr.h>
|
|
#include <log4cxx/helpers/tchar.h>
|
|
#include <time.h>
|
|
#include <log4cxx/logger.h>
|
|
#include <log4cxx/mdc.h>
|
|
#include <set>
|
|
|
|
namespace log4cxx
|
|
{
|
|
class Logger;
|
|
typedef helpers::ObjectPtrT<Logger> LoggerPtr;
|
|
|
|
class Level;
|
|
|
|
namespace helpers
|
|
{
|
|
class SocketOutputStream;
|
|
typedef helpers::ObjectPtrT<SocketOutputStream> SocketOutputStreamPtr;
|
|
|
|
class SocketInputStream;
|
|
typedef helpers::ObjectPtrT<SocketInputStream> SocketInputStreamPtr;
|
|
}
|
|
|
|
namespace spi
|
|
{
|
|
class LoggingEvent;
|
|
/** smart pointer to a LoggingEvent class */
|
|
typedef helpers::ObjectPtrT<LoggingEvent> LoggingEventPtr;
|
|
|
|
/**
|
|
The internal representation of logging events. When an affirmative
|
|
decision is made to log then a <code>LoggingEvent</code> instance
|
|
is created. This instance is passed around to the different log4cxx
|
|
components.
|
|
|
|
<p>This class is of concern to those wishing to extend log4cxx.
|
|
*/
|
|
class LOG4CXX_EXPORT LoggingEvent :
|
|
public virtual helpers::ObjectImpl
|
|
{
|
|
public:
|
|
DECLARE_LOG4CXX_OBJECT(LoggingEvent)
|
|
BEGIN_LOG4CXX_CAST_MAP()
|
|
LOG4CXX_CAST_ENTRY(LoggingEvent)
|
|
END_LOG4CXX_CAST_MAP()
|
|
|
|
/** For serialization only
|
|
*/
|
|
LoggingEvent();
|
|
|
|
/**
|
|
Instantiate a LoggingEvent from the supplied parameters.
|
|
|
|
<p>Except #timeStamp all the other fields of
|
|
<code>LoggingEvent</code> are filled when actually needed.
|
|
<p>
|
|
@param fqnOfLoggerClass The fully qualified name of the calling
|
|
logger class.
|
|
@param logger The logger of this event.
|
|
@param level The level of this event.
|
|
@param message The message of this event.
|
|
@param file The file where this log statement was written.
|
|
@param line The line where this log statement was written.
|
|
*/
|
|
LoggingEvent(const String& fqnOfLoggerClass,
|
|
const LoggerPtr& logger,
|
|
const LevelPtr& level, const String& message,
|
|
const char* file=0, int line=-1);
|
|
|
|
~LoggingEvent();
|
|
|
|
/** Return the #level of this event. */
|
|
inline const LevelPtr& getLevel() const
|
|
{ return level; }
|
|
|
|
/** Return the name of the #logger. */
|
|
const String& getLoggerName() const;
|
|
|
|
/** Return the #message for this logging event. */
|
|
inline const String& getMessage() const
|
|
{ return message; }
|
|
|
|
/** Return the #message for this logging event. */
|
|
inline const String& getRenderedMessage() const
|
|
{ return message; }
|
|
|
|
/**Returns the time when the application started,
|
|
in seconds elapsed since 01.01.1970.
|
|
*/
|
|
static int64_t getStartTime()
|
|
{ return startTime; }
|
|
|
|
/** Return the #threadId of this event. */
|
|
inline unsigned long getThreadId() const
|
|
{ return threadId; }
|
|
|
|
/** Return the #timeStamp of this event. */
|
|
inline int64_t getTimeStamp() const
|
|
{ return timeStamp; }
|
|
|
|
/* Return the file where this log statement was written. */
|
|
inline char * getFile() const
|
|
{ return file; }
|
|
|
|
/* Return the line where this log statement was written. */
|
|
inline int getLine() const
|
|
{ return line; }
|
|
|
|
/**
|
|
* This method returns the NDC for this event. It will return the
|
|
* correct content even if the event was generated in a different
|
|
* thread or even on a different machine. The NDC#get method
|
|
* should <em>never</em> be called directly. */
|
|
const String& getNDC() const;
|
|
|
|
/** Write this event to a helpers::SocketOutputStream. */
|
|
void write(helpers::SocketOutputStreamPtr& os) const;
|
|
|
|
void writeLevel(helpers::SocketOutputStreamPtr& os) const;
|
|
|
|
/** Read this event from a helpers::SocketOutputStream. */
|
|
void read(const helpers::SocketInputStreamPtr& is);
|
|
|
|
void readLevel(const helpers::SocketInputStreamPtr& is);
|
|
|
|
/**
|
|
* Returns the the context corresponding to the <code>key</code> parameter.
|
|
* If there is a local MDC copy, possibly because we are in a logging
|
|
* server or running inside AsyncAppender, then we search for the key in
|
|
* MDC copy, if a value is found it is returned. Otherwise, if the search
|
|
* in MDC copy returns an empty result, then the current thread's
|
|
* <code>MDC</code> is used.
|
|
*
|
|
* <p>
|
|
* Note that <em>both</em> the local MDC copy and the current thread's MDC
|
|
* are searched.
|
|
* </p>
|
|
*/
|
|
String getMDC(const String& key) const;
|
|
|
|
/**
|
|
* Returns the set of of the key values in the MDC for the event.
|
|
* The returned set is unmodifiable by the caller.
|
|
*
|
|
* @return Set an unmodifiable set of the MDC keys.
|
|
* @since 1.3
|
|
*/
|
|
std::set<String> getMDCKeySet() const;
|
|
|
|
/**
|
|
Obtain a copy of this thread's MDC prior to serialization
|
|
or asynchronous logging.
|
|
*/
|
|
void getMDCCopy() const;
|
|
|
|
/**
|
|
* Return a previously set property. The return value can be null.
|
|
*/
|
|
String getProperty(const String& key) const;
|
|
/**
|
|
* Returns the set of of the key values in the properties
|
|
* for the event. The returned set is unmodifiable by the caller.
|
|
*
|
|
* @return Set an unmodifiable set of the property keys.
|
|
*/
|
|
std::set<String> getPropertyKeySet() const;
|
|
|
|
/**
|
|
* Set a string property using a key and a string value. since 1.3
|
|
*/
|
|
void setProperty(const String& key, const String& value);
|
|
|
|
public:
|
|
/**
|
|
* Fully qualified name of the calling category class.
|
|
*/
|
|
String fqnOfCategoryClass;
|
|
|
|
private:
|
|
/**
|
|
* The logger of the logging event. This field is not serialized for
|
|
* performance reasons.
|
|
*
|
|
* <p>
|
|
* It is set by the LoggingEvent constructor or set by a remote
|
|
* entity after deserialization.
|
|
**/
|
|
LoggerPtr logger;
|
|
|
|
/** level of logging event. */
|
|
LevelPtr level;
|
|
|
|
/** The nested diagnostic context (NDC) of logging event. */
|
|
String ndc;
|
|
|
|
/** The mapped diagnostic context (MDC) of logging event. */
|
|
MDC::Map mdcCopy;
|
|
|
|
/**
|
|
* A map of String keys and String values.
|
|
*/
|
|
std::map<String, String> * properties;
|
|
|
|
/** Have we tried to do an NDC lookup? If we did, there is no need
|
|
* to do it again. Note that its value is always false when
|
|
* serialized. Thus, a receiving SocketNode will never use it's own
|
|
* (incorrect) NDC. See also writeObject method.
|
|
*/
|
|
bool ndcLookupRequired;
|
|
|
|
/**
|
|
* Have we tried to do an MDC lookup? If we did, there is no need to do it
|
|
* again. Note that its value is always false when serialized. See also
|
|
* the getMDC and getMDCCopy methods.
|
|
*/
|
|
bool mdcCopyLookupRequired;
|
|
|
|
/** The application supplied message of logging event. */
|
|
String message;
|
|
|
|
/** The name of thread in which this logging event was generated. */
|
|
//const LOG4CPLUS_THREAD_KEY_TYPE thread;
|
|
|
|
/** The number of milliseconds elapsed from 1/1/1970 until logging event
|
|
was created. */
|
|
int64_t timeStamp;
|
|
|
|
/** The is the file where this log statement was written. */
|
|
char* file;
|
|
std::string fileFromStream;
|
|
|
|
/** The is the line where this log statement was written. */
|
|
int line;
|
|
|
|
/** The identifier of thread in which this logging event
|
|
was generated.
|
|
*/
|
|
unsigned long threadId;
|
|
|
|
static int64_t startTime;
|
|
};
|
|
}
|
|
}
|
|
|
|
#endif //_LOG4CXX_SPI_LOGGING_EVENT_H
|