a Log for transmitting log messages as events. More...

#include <EventLog.h>

Inheritance diagram for lsst.ctrl.events::EventLog:

Public Member Functions
	EventLog (const std::string runId, int sliceId, const std::string hostId="", int threshold=pexLogging::Log::INFO)
	constructor for EventLog. More...

	EventLog (const std::string runId, int sliceId, const PropertySet::Ptr &preamble, const std::string hostId="", int threshold=pexLogging::Log::INFO)
	constructor for EventLog. More...

virtual	~EventLog ()
	destructor More...

int	getEventThreshold ()

void	setEventThreshold (int thres)

Public Member Functions inherited from lsst::pex::logging::Log
	Log (const int threshold=INFO, const std::string &name="")

	Log (const std::list< boost::shared_ptr< LogDestination > > &destinations, const lsst::daf::base::PropertySet &preamble, const std::string &name="", const int threshold=INFO, bool defaultShowAll=false)

	Log (const Log &parent, const std::string &childName, int threshold=INHERIT_THRESHOLD)

	Log (const Log &that)

virtual	~Log ()

Log &	operator= (const Log &that)

const std::string &	getName () const

int	getThreshold () const

void	setThreshold (int threshold)

bool	sends (int importance) const

void	resetThreshold ()

void	setThresholdFor (const std::string &name, int threshold)

int	getThresholdFor (const std::string &name) const

bool	willShowAll () const

void	setShowAll (bool yesno)

void	resetShowAll ()

template<class T >
void	addPreambleProperty (const std::string &name, const T &val)

template<class T >
void	setPreambleProperty (const std::string &name, const T &val)

Log *	createChildLog (const std::string &childName, int threshold=INHERIT_THRESHOLD) const

void	log (int importance, const std::string &message, const lsst::daf::base::PropertySet &properties)

template<class T >
void	log (int importance, const std::string &message, const std::string &name, const T &val)

template<class T >
void	log (int importance, const std::string &message, const RecordProperty< T > &prop)

void	log (int importance, const std::string &message)

void	log (int importance, const boost::format &message)

void	logdebug (const std::string &message, const lsst::daf::base::PropertySet &properties)

template<class T >
void	logdebug (const std::string &message, const std::string &name, const T &val)

template<class T >
void	logdebug (const std::string &message, const RecordProperty< T > &prop)

void	logdebug (const std::string &message)

void	logdebug (const boost::format &message)

void	info (const std::string &message, const lsst::daf::base::PropertySet &properties)

template<class T >
void	info (const std::string &message, const std::string &name, const T &val)

template<class T >
void	info (const std::string &message, const RecordProperty< T > &prop)

void	info (const std::string &message)

void	info (const boost::format &message)

void	warn (const std::string &message, const lsst::daf::base::PropertySet &properties)

template<class T >
void	warn (const std::string &message, const std::string &name, const T &val)

template<class T >
void	warn (const std::string &message, const RecordProperty< T > &prop)

void	warn (const std::string &message)

void	warn (const boost::format &message)

void	fatal (const std::string &message, const lsst::daf::base::PropertySet &properties)

template<class T >
void	fatal (const std::string &message, const std::string &name, const T &val)

template<class T >
void	fatal (const std::string &message, const RecordProperty< T > &prop)

void	fatal (const std::string &message)

void	fatal (const boost::format &message)

void	format (int importance, const char *fmt,...)

void	debugf (const char *fmt,...)

void	infof (const char *fmt,...)

void	warnf (const char *fmt,...)

void	fatalf (const char *fmt,...)

void	send (const LogRecord &record)

void	addDestination (std::ostream &destination, int threshold)

void	addDestination (std::ostream &destination, int threshold, const boost::shared_ptr< LogFormatter > &formatter)

void	addDestination (const boost::shared_ptr< LogDestination > &destination)

const lsst::daf::base::PropertySet &	getPreamble ()

void	markPersistent ()

void	printThresholds (std::ostream &out)

void	reset ()

Static Public Member Functions
static void	createDefaultLog (const std::string runId, int slideId, const std::string hostId="", int threshold=Log::INFO)
	creates a default log More...

static void	createDefaultLog (const std::string runId, int slideId, const PropertySet::Ptr &preamble, const std::string hostId="", int threshold=Log::INFO)

Static Public Member Functions inherited from lsst::pex::logging::Log
static Log &	getDefaultLog ()

static void	createDefaultLog (const std::list< boost::shared_ptr< LogDestination > > &destinations, const lsst::daf::base::PropertySet &preamble, const std::string &name="", const int threshold=INFO)

static void	closeDefaultLog ()

Static Public Attributes
static const std::string	LOGGING_TOPIC = "logging"

Static Public Attributes inherited from lsst::pex::logging::Log
static const int	DEBUG

static const int	INFO

static const int	WARN

static const int	INHERIT_THRESHOLD

static const int	FATAL

Private Member Functions
void	init (const std::string runId, int sliceId, const PropertySet::Ptr &preamble, const std::string hostId, int threshold)

void	initThres (int threshold)

Private Attributes
pexLogging::LogDestination *	_log

EventFormatter *	_formatter

Additional Inherited Members
Protected Member Functions inherited from lsst::pex::logging::Log
void	_send (int threshold, int importance, const char *fmt, va_list ap)

void	_format (int importance, const char *fmt, va_list ap)

Static Protected Member Functions inherited from lsst::pex::logging::Log
static void	setDefaultLog (Log *deflog)

Protected Attributes inherited from lsst::pex::logging::Log
boost::shared_ptr < threshold::Memory >	_thresholds

std::list< boost::shared_ptr < LogDestination > >	_destinations

lsst::daf::base::PropertySet::Ptr	_preamble

Static Protected Attributes inherited from lsst::pex::logging::Log
static Log *	defaultLog

static const std::string	_sep

Detailed Description

a Log for transmitting log messages as events.

Definition at line 58 of file EventLog.h.

Constructor & Destructor Documentation

lsst.ctrl.events::EventLog::EventLog	(	const std::string	runId,
		int	sliceId,
		const std::string	hostId = `""`,
		int	threshold = `pexLogging::Log::INFO`
	)

constructor for EventLog.

Parameters

runId	name of the run
sliceId	the current slice id
hostId	the name for this host.
threshold	threshold of this log. Default is threshold is Log::INFO

Definition at line 64 of file EventLog.cc.

     :  pexLogging::Log(threshold)
 {
     PropertySet::Ptr psp;
     init(runId, sliceId, psp, hostId, threshold);
 }

lsst.ctrl.events::EventLog::EventLog	(	const std::string	runId,
		int	sliceId,
		const PropertySet::Ptr &	preamble,
		const std::string	hostId = `""`,
		int	threshold = `pexLogging::Log::INFO`
	)

constructor for EventLog.

Parameters

runId	name of the run
sliceId	the current slice id
preamble	a list of PropertySet to include in each log message.
hostId	the name for this host.
threshold	threshold of this log. Default is threshold is Log::INFO

Definition at line 78 of file EventLog.cc.

     :  Log(threshold)
 {
     init(runId, sliceId, preamble, hostId, threshold);
 }

lsst.ctrl.events::EventLog::~EventLog ( )

virtual

destructor

Definition at line 142 of file EventLog.cc.

142 {

143 }

Member Function Documentation

void lsst.ctrl.events::EventLog::createDefaultLog	(	const std::string	runId,
		int	sliceId,
		const std::string	hostId = `""`,
		int	threshold = `Log::INFO`
	)

static

creates a default log

Parameters

runId	name of the run
sliceId	the current slice id
hostId	the name of this host
threshold	the logging threshold to observe when sending log messages

Definition at line 131 of file EventLog.cc.

                                                                                                           {
     PropertySet::Ptr psp;
     pexLogging::Log::setDefaultLog(new EventLog(runId, sliceId, psp, hostId, threshold));
 }

void lsst.ctrl.events::EventLog::createDefaultLog	(	const std::string	runId,
		int	slideId,
		const PropertySet::Ptr &	preamble,
		const std::string	hostId = `""`,
		int	threshold = `Log::INFO`
	)

static

Definition at line 136 of file EventLog.cc.

                                                                                                                                           {
     pexLogging::Log::setDefaultLog(new EventLog(runId, sliceId, preamble, hostId, threshold));
 }

int lsst.ctrl.events::EventLog::getEventThreshold ( )

inline

Definition at line 67 of file EventLog.h.

67 { return _log->getThreshold(); }

lsst.ctrl.events::EventLog::_log

pexLogging::LogDestination * _log

Definition: EventLog.h:76

lsst::pex::logging::LogDestination::getThreshold

int getThreshold() const

Definition: LogDestination.h:99

void lsst.ctrl.events::EventLog::init	(	const std::string	runId,
		int	sliceId,
		const PropertySet::Ptr &	preamble,
		const std::string	hostId,
		int	threshold
	)

private

private method to initialize from each constructor

Definition at line 86 of file EventLog.cc.

 {
 
     initThres(threshold);
     long int host_len = sysconf(_SC_HOST_NAME_MAX);
 
     boost::scoped_array<char> host(new char[host_len]);
 
     // if there is no host name specified, make "unknown host" the name
     if (hostId.size() == 0) {
         if (gethostname(host.get(), host_len) < 0)
             std::strcpy(host.get(), "unknown host");
     } else
         std::strcpy(host.get(), hostId.c_str());
 
     std::string hostName(host.get());
 
     // TODO:  add preamble to _preamble
     if (preamble.get() != 0)
         _preamble = preamble->deepCopy();
 
     // this will be added by the Event object
     // _preamble->add("hostId", hostName);
     _preamble->add("RUNID", runId);
     _preamble->add("SLICEID", sliceId);
 }

void lsst.ctrl.events::EventLog::initThres ( int threshold )

private

private method to initialize the logging mechanism

Definition at line 115 of file EventLog.cc.

 {
     _formatter = new EventFormatter();
     boost::shared_ptr<pexLogging::LogFormatter> fmtr(_formatter);
 
     _log = new pexLogging::LogDestination(&clog, fmtr, INHERIT_THRESHOLD);
     boost::shared_ptr<pexLogging::LogDestination> dest(_log);
     _destinations.push_back(dest);
 }

void lsst.ctrl.events::EventLog::setEventThreshold ( int thres )

inline

Definition at line 69 of file EventLog.h.

69 {_log->setThreshold(thres); }

lsst.ctrl.events::EventLog::_log

pexLogging::LogDestination * _log

Definition: EventLog.h:76

lsst::pex::logging::LogDestination::setThreshold

void setThreshold(int threshold)

Definition: LogDestination.h:106

Member Data Documentation

EventFormatter* lsst.ctrl.events::EventLog::_formatter

private

Definition at line 77 of file EventLog.h.

pexLogging::LogDestination* lsst.ctrl.events::EventLog::_log

private

Definition at line 76 of file EventLog.h.

const std::string lsst.ctrl.events::EventLog::LOGGING_TOPIC = "logging"

static

Definition at line 60 of file EventLog.h.

The documentation for this class was generated from the following files:

/lsst/home/lsstsw/stack/Linux64/ctrl_events/master-gcf15f11bcc/include/lsst/ctrl/events/EventLog.h
/lsst/home/lsstsw/stack/Linux64/ctrl_events/master-gcf15f11bcc/src/EventLog.cc

Public Member Functions

Static Public Member Functions

Static Public Attributes

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation