lsst::pex::harness::TracingLog Class Reference

#include <TracingLog.h>

Inheritance diagram for lsst::pex::harness::TracingLog:

Public Member Functions
	TracingLog (const logging::Log &parent, const std::string &name, int tracelev=TracingLog::TRACE, const std::string &funcName="")
	TracingLog (const TracingLog &that)
TracingLog &	operator= (const TracingLog &that)
TracingLog *	createForTraceBlock (const std::string &name, int tracelev=logging::Log::INHERIT_THRESHOLD, const std::string &funcName="")
TracingLog *	traceBlock (const std::string &name, int tracelev=logging::Log::INHERIT_THRESHOLD, const std::string &funcName="")
virtual	~TracingLog ()
void	start ()
void	start (const std::string &funcName)
void	done ()
int	getTraceLevel () const
const std::string &	getFunctionName () const
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 Attributes
static const int	TRACE = logging::Log::INFO - 1
static const std::string	STATUS
static const std::string	START
static const std::string	END
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 Attributes
int	_tracelev
std::string	_funcName

Additional Inherited Members
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 ()
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 specialized Log that assists the harness in tracing execution flow.

The motivation for this class is to provide uniformity in the log messages that indicate the start and finish of some section of code. This makes it easier to locate these records after execution and calculate the time spent in the traced code.

Definition at line 50 of file TracingLog.h.

Constructor & Destructor Documentation

lsst::pex::harness::TracingLog::TracingLog	(	const logging::Log &	parent,
		const std::string &	name,
		int	tracelev = TracingLog::TRACE,
		const std::string &	funcName = ""
	)

construct a TracingLog.

Parameters

parent	the parent log to inherit attributes from
name	the name to give the log relative to its parent
tracelev	the default level to use for the tracing messages
funcName	the name of the block of code (e.g. function) being traced. If empty, the value given by name will be used instead. This value will be used in the log message only.

Definition at line 45 of file TracingLog.cc.

    : Log(parent, name), _tracelev(tracelev), _funcName(funcName)
{
    if (_funcName.length() == 0) _funcName = name;
    if (_tracelev == logging::Log::INHERIT_THRESHOLD) {
        const TracingLog *p = dynamic_cast<const TracingLog*>(&parent);
        if (p) {
            _tracelev = p->getTraceLevel();
        }
        else {
            _tracelev = TRACE;
        }
    }
}

lsst::pex::harness::TracingLog::TracingLog ( const TracingLog &  that )

inline

create a copy of a TracingLog

Definition at line 92 of file TracingLog.h.

        : Log(*this), _tracelev(that._tracelev), _funcName(that._funcName)
    { }

lsst::pex::harness::TracingLog::~TracingLog ( )

virtual

delete the log

Definition at line 61 of file TracingLog.cc.

{ }

Member Function Documentation

TracingLog* lsst::pex::harness::TracingLog::createForTraceBlock ( const std::string &  name, int  tracelev = logging::Log::INHERIT_THRESHOLD, const std::string &  funcName = ""  )

inline

create and return a new child that should be used while tracing a function. A "start" message will be logged to the new log as part of the call. Like createChildLog(), the caller is responsible for deleting this new instance when finished with it.

Parameters

name	the name to give the log relative to its parent
tracelev	the default level to use for the tracing messages. If equal to Log::INHERIT_THRESHOLD (default), it will be set to this log's tracing level.
funcName	the name of the block of code (e.g. function) being traced. If empty, the value given by name will be used instead. This value will be used in the log message only.

Definition at line 120 of file TracingLog.h.

    {
        TracingLog *out = new TracingLog(*this, name, tracelev, funcName);
        // out->setShowAll(true);
        out->start();
        return out;
    }

void lsst::pex::harness::TracingLog::done ( )

inline

Indicate that the section of code being traced (e.g. a function body) is finished.

Definition at line 170 of file TracingLog.h.

                {
        if (sends(_tracelev)) {
            std::string msg("Ending ");
            msg += _funcName;
            log(_tracelev, msg, STATUS, END);
        }
    }

const std::string& lsst::pex::harness::TracingLog::getFunctionName ( ) const

inline

return the name of the code block being traced which will appear in the start and end messages.

Definition at line 188 of file TracingLog.h.

{ return _funcName; }

int lsst::pex::harness::TracingLog::getTraceLevel ( ) const

inline

return the tracing message level, the importance to be given to the start and end messages.

Definition at line 182 of file TracingLog.h.

{ return _tracelev; }

TracingLog& lsst::pex::harness::TracingLog::operator= ( const TracingLog &  that )

inline

reset this instance to another

Definition at line 99 of file TracingLog.h.

                                                  {
        Log::operator=(that);
        _tracelev = that._tracelev;
        _funcName = that._funcName;
        return *this;
    }

void lsst::pex::harness::TracingLog::start ( )

inline

Indicate that the section of code being traced (e.g. a function body) is starting.

Definition at line 149 of file TracingLog.h.

                 {
        if (sends(_tracelev)) {
            std::string msg("Starting ");
            msg += _funcName;
            log(_tracelev, msg, STATUS, START);
        }
    }

void lsst::pex::harness::TracingLog::start ( const std::string &  funcName )

inline

Indicate that the section of code being traced (e.g. a function body) is starting.

Definition at line 161 of file TracingLog.h.

                                          {
        if (funcName.length() > 0) _funcName = funcName;
        start();
    }

TracingLog* lsst::pex::harness::TracingLog::traceBlock ( const std::string &  name, int  tracelev = logging::Log::INHERIT_THRESHOLD, const std::string &  funcName = ""  )

inline

a synonym for createForTraceBlock

Definition at line 133 of file TracingLog.h.

    {
        return createForTraceBlock(name, tracelev, funcName);
    }

Member Data Documentation

std::string lsst::pex::harness::TracingLog::_funcName

private

Definition at line 192 of file TracingLog.h.

int lsst::pex::harness::TracingLog::_tracelev

private

Definition at line 191 of file TracingLog.h.

const std::string lsst::pex::harness::TracingLog::END

static

the property to use to mark the start of a block of code being traced

Definition at line 73 of file TracingLog.h.

const std::string lsst::pex::harness::TracingLog::START

static

the property to use to mark the start of a block of code being traced

Definition at line 67 of file TracingLog.h.

const std::string lsst::pex::harness::TracingLog::STATUS

static

the property name that will indicate what a trace message is marking

Definition at line 61 of file TracingLog.h.

const int lsst::pex::harness::TracingLog::TRACE = logging::Log::INFO - 1

static

default message level for messages that trace execution flow

Definition at line 56 of file TracingLog.h.

---

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

• /lsst/home/lsstsw/stack/Linux64/pex_harness/master-g084aeec0a4/include/lsst/pex/harness/TracingLog.h
• /lsst/home/lsstsw/stack/Linux64/pex_harness/master-g084aeec0a4/src/TracingLog.cc