Logging

Topics
	Integer Logger Levels
	Logging Macros

Files
file	Logger.h
	Header file for the nidas::util logging facility.

Classes
class	nidas::util::LogContextState
	LogContextState holds the status members of a LogContext and related behavior. More...
class	nidas::util::LogContext
	The LogContext is created at a point in the application code and filled in with details about that log point, such as the file and line number, and the function name of the containing function, and the log level of that log point, such as LOGGER_DEBUG or LOGGER_ERROR. More...
class	nidas::util::LogConfig
	A configuration to enable or disable a matching set of log points. More...
class	nidas::util::LogScheme
	A LogScheme is a vector of LogConfig's and the vector of fields to show in log messages. More...
class	nidas::util::LogMessage
	A class for formatting and streaming a log message. More...
class	nidas::util::Logger
	Simple logging class, based on UNIX syslog interface. More...

Macros
#define	LOG_CONTEXT(LEVEL)    nidas::util::LEVEL, __FILE__, __PRETTY_FUNCTION__, __LINE__
#define	LOG_STATIC_CONTEXT(LEVEL)    nidas::util::LEVEL, __FILE__, "file_static_scope", __LINE__
	Expand to LogContext tuple outside function scope.
#define	LOG_EMERG   LOG_CONTEXT(LOGGER_EMERG)
#define	LOG_ALERT   LOG_CONTEXT(LOGGER_ALERT)
#define	LOG_CRIT   LOG_CONTEXT(LOGGER_CRIT)
#define	LOG_ERR   LOG_CONTEXT(LOGGER_ERR)
#define	LOG_WARNING   LOG_CONTEXT(LOGGER_WARNING)
#define	LOG_NOTICE   LOG_CONTEXT(LOGGER_NOTICE)
#define	LOG_INFO   LOG_CONTEXT(LOGGER_INFO)
#define	LOG_DEBUG   LOG_CONTEXT(LOGGER_DEBUG)
#define	LOG_VERBOSE   LOG_CONTEXT(LOGGER_VERBOSE)
#define	LOGGER_LOGPOINT(LEVEL, TAGS, MSG)
	This macro creates a static LogContext instance that is not in thread-local storage and therefore is not thread-safe.

Functions
int	nidas::util::stringToLogLevel (const std::string &slevel)
	Convert the name of a log level to its integer value.
string	nidas::util::logLevelToString (int)
	Convert an integral log level to a string name.
LogMessage &	nidas::util::endlog (LogMessage &logmsg)
	LogMessage manipulator which logs the current message buffer, if any, and then clears the message.
LogMessage &	nidas::util::operator<< (LogMessage &logmsg, LogMessage &(*op)(LogMessage &))
	Template to call LogMessage manipulators like endlog when streamed to a LogMessage.
template<typename T >
LogMessage &	nidas::util::LogMessage::operator<< (const T &t)
	Everything streamed to a LogMessage is passed on to the underlying ostringstream, including ostream manipulators.
void	nidas::util::LogContextState::log (const std::string &msg) const
	Convenience method which writes the given message to the current Logger instance, passing this object as the LogContextState.
LogMessage	nidas::util::LogContextState::log () const
	Return a LogMessage associated with this LogContextState, so the message will be logged through this context when the LogMessage goes out of scope.
template<typename T >
T	nidas::util::LogScheme::getParameterT (const std::string &name, const T &dvalue=T())
	Lookup a parameter with name name in a LogScheme and convert the value to the type of the dvalue parameter.
const int	nidas::util::LOGGER_EMERGENCY = LOG_EMERG
const int	nidas::util::LOGGER_ALERT = LOG_ALERT
const int	nidas::util::LOGGER_CRIT = LOG_CRIT
const int	nidas::util::LOGGER_CRITICAL = LOG_CRIT
const int	nidas::util::LOGGER_ERROR = LOG_ERR
const int	nidas::util::LOGGER_ERR = LOG_ERR
const int	nidas::util::LOGGER_PROBLEM = LOG_ERR
const int	nidas::util::LOGGER_WARNING = LOG_WARNING
const int	nidas::util::LOGGER_NOTICE = LOG_NOTICE
const int	nidas::util::LOGGER_INFO = LOG_INFO
const int	nidas::util::LOGGER_DEBUG = LOG_DEBUG
const int	nidas::util::LOGGER_VERBOSE = LOG_DEBUG+1
const int	nidas::util::LOGGER_NONE = LOG_EMERG-1
#define	ALOG(MSG)   LOGGER_LOGPOINT(LOGGER_ALERT,"",MSG)
#define	CLOG(MSG)   LOGGER_LOGPOINT(LOGGER_CRITICAL,"",MSG)
#define	PLOG(MSG)   LOGGER_LOGPOINT(LOGGER_ERR,"",MSG)
#define	WLOG(MSG)   LOGGER_LOGPOINT(LOGGER_WARNING,"",MSG)
#define	NLOG(MSG)   LOGGER_LOGPOINT(LOGGER_NOTICE,"",MSG)
#define	ILOG(MSG)   LOGGER_LOGPOINT(LOGGER_INFO,"",MSG)
#define	DLOG(MSG)   LOGGER_LOGPOINT(LOGGER_DEBUG,"",MSG)
#define	VLOG(MSG)   LOGGER_LOGPOINT(LOGGER_VERBOSE,"",MSG)
#define	ELOGT(TAGS, MSG)   LOGGER_LOGPOINT(LOGGER_EMERG,TAGS,MSG)
#define	ALOGT(TAGS, MSG)   LOGGER_LOGPOINT(LOGGER_ALERT,TAGS,MSG)
#define	CLOGT(TAGS, MSG)   LOGGER_LOGPOINT(LOGGER_CRITICAL,TAGS,MSG)
#define	PLOGT(TAGS, MSG)   LOGGER_LOGPOINT(LOGGER_ERR,TAGS,MSG)
#define	WLOGT(TAGS, MSG)   LOGGER_LOGPOINT(LOGGER_WARNING,TAGS,MSG)
#define	NLOGT(TAGS, MSG)   LOGGER_LOGPOINT(LOGGER_NOTICE,TAGS,MSG)
#define	ILOGT(TAGS, MSG)   LOGGER_LOGPOINT(LOGGER_INFO,TAGS,MSG)
#define	DLOGT(TAGS, MSG)   LOGGER_LOGPOINT(LOGGER_DEBUG,TAGS,MSG)
#define	VLOGT(TAGS, MSG)   LOGGER_LOGPOINT(LOGGER_VERBOSE,TAGS,MSG)

Detailed Description

Three main classes comprise the nidas::util logging facility:

• nidas::util::LogContext
• nidas::util::Logger
• nidas::util::LogConfig

The intended use of this interface is through the Logging Macros. These macros automatically instantiate a LogContext and control the formatting and sending of the log message according to the current logging configuration. The advantage of the macros is that they are less verbose and there is no overhead formatting the message parameters if the log message is not currently enabled. However, the original form of calling the Logger::log() method directly still works. That form could be more natural in some cases. It is equivalent to the macros except the log message call cannot suppressed: the message itself is suppressed within the log() method by checking the LogContext against the current configuration. The syslog macros like LOG_EMERG are redefined to be a comma-separated list of the LogContext parameters, so those parameters are passed into the log() call. In other words, consider original logging code that looks like this:

n_u::Logger::getInstance()->log(LOG_INFO,
   "~DSMEngine %s: %s",output->getName().c_str(),e.what());

LOG_INFO is expanded to this:

nidas::util::LOGGER_INFO, __FILE__, __PRETTY_FUNCTION__, __LINE__

So the log() call receives all of the context information it needs to first of all compile a more complete log message, and second to determine if the message has been enabled.

The log() call above could be rewritten using a macro as follows:

ILOG(("~DSMEngine %s: %s",output->getName().c_str(),e.what()));

or alternatively with ostream operators:

ILOG(("~DSMEngine ") << output->getName() << ": " << e.what());

LogConfig objects can be created to configure the set of log points which will be active. See Logging Configuration Schemes.

NIDAS can configure the available logging schemes and the current scheme through the XML config file. Below is an excerpt from within the <project> element. The log scheme is set with the <logger> element.

Todo

A nice enhancement someday would be to set the log scheme name from the dsm command-line.

 <logger scheme='everything' />
 
 <logscheme name='everything'>
 <showfields>all</showfields>
 <logconfig level='debug'/>
 <logconfig filematch='nidas'/>
 </logscheme>
 
 <logscheme name='everything-but-utils'>
 <showfields>all</showfields>
 <logconfig level='debug'/>
 <logconfig filematch='util' activate='false'/>
 </logscheme>
 
<logscheme name='nothing'>
    </logscheme>
 
    <logscheme name='info'>
    <logconfig level='info'/>
    </logscheme>
 
    <logscheme name='sampledebug'>
    <logconfig level='debug'/>
    <logconfig tagmatch='samples'/>
    </logscheme>
 
    <logscheme name='iss-debug'>
    <showfields>level,time,function,message</showfields>
    <logconfig filematch='dynld/iss'/>
    </logscheme>
 
    <logscheme name='tilt-sensor-debug'>
    <logconfig filematch='dynld/iss'/>
    <logconfig filematch='nidas/core'/>
    </logscheme>

Macro Definition Documentation

ALOG

#define ALOG

(

MSG

)

LOGGER_LOGPOINT(LOGGER_ALERT,"",MSG)

ALOGT

#define ALOGT	(		TAGS,
			MSG )   LOGGER_LOGPOINT(LOGGER_ALERT,TAGS,MSG)

CLOG

#define CLOG

(

MSG

)

LOGGER_LOGPOINT(LOGGER_CRITICAL,"",MSG)

Referenced by nidas::util::Cond::~Cond(), nidas::util::Mutex::~Mutex(), PacketReader::~PacketReader(), and nidas::util::RWLock::~RWLock().

CLOGT

#define CLOGT	(		TAGS,
			MSG )   LOGGER_LOGPOINT(LOGGER_CRITICAL,TAGS,MSG)

DLOG

#define DLOG

(

MSG

)

LOGGER_LOGPOINT(LOGGER_DEBUG,"",MSG)

Referenced by nidas::util::McSocketListener::add(), nidas::util::McSocketListener::add(), nidas::dynld::raf::SyncRecordGenerator::addSampleClient(), nidas::dynld::iss::WICORSensor::addSampleTag(), nidas::core::TimetagAdjuster::adjust(), nidas::core::IOStream::backup(), nidas::core::SerialSensor::buildSampleScanner(), nidas::dynld::GPS_NMEA_Serial::buildSampleScanner(), nidas::core::FsMount::cancel(), nidas::core::NidasApp::checkRequiredArguments(), nidas::core::SampleOutputBase::close(), nidas::util::ServerSocket::close(), nidas::dynld::SampleInputStream::closeBlocks(), nidas::util::FileSet::closeFile(), nidas::dynld::raf::SyncRecordSource::connect(), nidas::dynld::StatisticsCruncher::connect(), nidas::dynld::XMLConfigService::connected(), nidas::core::DSMEngine::connectOutputs(), copy_variables_to_record(), DataStats::createCounters(), nidas::util::FileSet::createDirectory(), nidas::util::FileSet::createFile(), nidas::core::DOMObjectFactory::createObject(), nidas::util::SerialPort::createPty(), nidas::dynld::isff::CSAT3_Sonic::dataMode(), dataToInfluxDB(), nidas::core::SampleOutputRequestThread::destroyInstance(), nidas::dynld::RawSampleService::disconnect(), nidas::dynld::raf::SyncRecordReader::endOfStream(), nidas::core::DSMEngineIntf::SensorAction::execute(), nidas::core::Project::findDSM(), nidas::core::Project::findDSM(), nidas::core::Project::findDSM(), nidas::core::SampleSorter::flush(), nidas::dynld::raf::SyncRecordSource::flush(), nidas::dynld::raf::DSMArincSensor::fromDOMElement(), nidas::dynld::isff::Wind2D::fromDOMElement(), nidas::dynld::DSC_A2DSensor::getA2DSetup(), nidas::dynld::raf::A2D_Serial::getA2DSetup(), nidas::dynld::raf::DSMAnalogSensor::getA2DSetup(), nidas::util::Inet4NetworkInterface::getInterface(), nidas::dynld::SampleInputStream::handleEOF(), nidas::dynld::SampleInputStream::handleNewInput(), InfluxDB::handleResult(), nidas::core::SampleSorter::heapDecrement(), nidas::dynld::raf::SyncRecordReader::init(), nidas::dynld::raf::SyncServer::init(), nidas::dynld::raf::SyncRecordGenerator::init(), nidas::util::FileSet::initialize(), nidas::dynld::raf::SyncServer::initProject(), nidas::core::XmlRpcThread::interrupt(), nidas::dynld::raf::SyncServer::interrupt(), nidas::core::DSMEngine::joinDataThreads(), nidas::core::DSMServerApp::killStatusThread(), nidas::core::DSMEngine::killXmlRpcThread(), nidas::core::DSMServerApp::killXmlRpcThread(), PConfig::loadVariables(), nidas::core::NidasApp::lockMemory(), main(), nidas::core::DSMServerApp::main(), nidas::util::FileSet::matchFiles(), nidas::dynld::SampleInputStream::nextSample(), nidas::dynld::isff::CSAT3_Sonic::open(), nidas::dynld::ModbusRTU::open(), nidas::util::FileSet::openNextFile(), nidas::dynld::raf::SyncServer::openStream(), nidas::core::Polynomial::parseFields(), nidas::dynld::SampleInputStream::parseInputHeader(), NidsMerge::parseRunstring(), nidas::dynld::iss::WICORSensor::process(), nidas::dynld::raf::UDPArincSensor::process(), nidas::dynld::raf::DSMArincSensor::processAlta(), nidas::dynld::raf::TwoD64_USB::processImageRecord(), nidas::core::SamplePool< SampleType >::putSample(), nidas::core::SamplePool< SampleType >::putSample(), nidas::dynld::isff::CSAT3_Sonic::querySonic(), nidas::dynld::SampleInputStream::read(), nidas::dynld::raf::SyncServer::read(), nidas::core::SampleScanner::readBuffer(), nidas::core::VariableConverter::readCalFile(), DataStats::readHeader(), nidas::dynld::SampleInputStream::readInputHeader(), nidas::dynld::DSC_FreqCounter::readParams(), nidas::core::DSMSensor::readSamples(), DataStats::readSamples(), nidas::core::IOStream::reallocateBuffer(), nidas::core::SampleSorter::receive(), SampleDispatcher::receive(), DataStats::receive(), nidas::dynld::raf::DSMArincSensor::registerWithUDPArincSensor(), nidas::core::MultipleUDPSockets::removeClient(), nidas::core::requestXMLConfig(), PConfig::resolveCalFile(), DataStats::restartStats(), DataStats::run(), DataPrep::run(), NidsMerge::run(), StatsProcess::run(), TeeTTy::run(), nidas::core::DSMServerIntf::run(), nidas::core::Socket::ConnectionThread::run(), nidas::core::ServerSocket::ConnectionThread::run(), nidas::dynld::raf::SyncServer::run(), nidas::dynld::RawSampleService::Worker::run(), nidas::util::McSocketListener::run(), nidas::util::McSocketMulticaster< SocketTT >::run(), SampleDispatcher::SampleDispatcher(), nidas::core::SamplePool< SampleType >::SamplePool(), nidas::dynld::WxtSensor::scanSample(), nidas::dynld::SampleInputStream::search(), nidas::dynld::raf::PSI9116_Sensor::sendCommand(), InfluxDB::sendData(), nidas::dynld::raf::DSMMesaSensor::sendFPGACodeToDriver(), nidas::dynld::raf::SyncRecordGenerator::sendHeader(), nidas::core::CharacterSensor::sendInitString(), nidas::dynld::isff::CSAT3_Sonic::sendRateCommand(), nidas::dynld::raf::SyncRecordSource::sendSyncHeader(), nidas::dynld::isff::WindOrienter::setOrientation(), nidas::dynld::raf::SyncServer::setTimeWindow(), nidas::core::Looper::setupClientMaps(), nidas::core::NidasApp::setupProcess(), nidas::util::Thread::sigAction(), nidas::dynld::raf::SyncServer::signalStop(), nidas::dynld::raf::SyncServer::stop(), nidas::dynld::raf::PSI9116_Sensor::stopStreams(), nidas::dynld::isff::CSAT3_Sonic::terminalMode(), nidas::dynld::DSC_A2DSensor::testVoltage(), nidas::dynld::raf::A2D_Serial::testVoltage(), nidas::dynld::raf::DSMAnalogSensor::testVoltage(), nidas::dynld::isff::NCAR_TRH::validate(), nidas::dynld::isff::Wind2D::validate(), nidas::dynld::isff::Wind2D::validateSscanfs(), nidas::dynld::WxtSensor::wxtValidateSscanfs(), nidas::core::XmlRpcThread::XmlRpcThread(), nidas::core::SampleSorter::~SampleSorter(), nidas::core::ServerSocket::~ServerSocket(), nidas::dynld::raf::SyncRecordReader::~SyncRecordReader(), and nidas::dynld::raf::SyncServer::~SyncServer().

DLOGT

#define DLOGT	(		TAGS,
			MSG )   LOGGER_LOGPOINT(LOGGER_DEBUG,TAGS,MSG)

ELOGT

#define ELOGT	(		TAGS,
			MSG )   LOGGER_LOGPOINT(LOGGER_EMERG,TAGS,MSG)

ILOG

#define ILOG

(

MSG

)

LOGGER_LOGPOINT(LOGGER_INFO,"",MSG)

Referenced by nidas::core::SensorHandler::add(), nidas::core::MultipleUDPSockets::addClient(), nidas::dynld::UDPSampleOutput::ConnectionMonitor::addDestination(), nidas::dynld::StatisticsProcessor::addRequestedSampleTag(), nidas::core::FsMount::autoMount(), nidas::util::SerialPort::close(), nidas::core::ServerSocket::connect(), nidas::dynld::RawSampleService::connect(), nidas::core::SampleArchiver::connect(), nidas::dynld::raf::CVIProcessor::connect(), nidas::dynld::raf::SyncRecordGenerator::connect(), nidas::core::MultipleUDPSockets::connected(), nidas::util::FileSet::createDirectory(), nidas::util::FileSet::createFile(), InfluxDB::createInfluxDB(), nidas::dynld::isff::CSAT3_Sonic::dataMode(), nidas::core::SampleOutputBase::disconnect(), nidas::dynld::RawSampleService::disconnect(), nidas::core::SampleArchiver::disconnect(), nidas::dynld::raf::SyncRecordGenerator::disconnect(), nidas::dynld::raf::DSMMesaSensor::DSMMesaSensor(), InfluxDB::flush(), nidas::core::Project::fromDOMElement(), nidas::dynld::raf::DSMMesaSensor::fromDOMElement(), nidas::core::NidasApp::getDataset(), nidas::dynld::GPS_Novatel_Serial::gps_to_utc(), nidas::core::RemoteSerialConnection::handlePollEvents(), nidas::core::SensorHandler::handlePollingChange(), nidas::dynld::isff::NCAR_TRH::handleRawRH(), nidas::dynld::isff::NCAR_TRH::handleRawT(), nidas::core::SensorHandler::incrementFullBufferReads(), nidas::core::DSMEngine::initialize(), nidas::core::DSMServer::joinServices(), DataStats::jsonReport(), StatsProcess::listOutputSamples(), PConfig::loadRemoteXML(), nidas::core::NidasApp::lockMemory(), PConfig::main(), main(), nidas::core::DSMEngine::main(), nidas::core::FsMount::mount(), nidas::core::CalFile::open(), nidas::dynld::raf::DSMArincSensor::open(), nidas::dynld::raf::DSMMesaSensor::open(), nidas::dynld::raf::UDPArincSensor::open(), nidas::dynld::raf::UDPiPMSensor::open(), nidas::util::SerialPort::open(), nidas::util::FileSet::openNextFile(), nidas::dynld::raf::SyncRecordSource::preLoadCalibrations(), nidas::dynld::isff::CSI_IRGA_Sonic::process(), nidas::util::Thread::pRun(), nidas::dynld::isff::WisardMote::readHead(), SampleCounter::receive(), nidas::util::SocketImpl::receive(), nidas::util::SocketImpl::receive(), nidas::util::SocketImpl::recv(), nidas::util::SocketImpl::recvfrom(), nidas::core::Project::removeAutoConfig(), nidas::core::MultipleUDPSockets::removeClient(), nidas::core::MultipleUDPSockets::removeClient(), DataStats::report(), nidas::core::ServerSocket::requestConnection(), DataStats::run(), DataPrep::run(), WriterThread::run(), ServerThread::run(), StatsProcess::run(), nidas::core::Looper::run(), nidas::core::SampleSorter::run(), nidas::core::SensorHandler::run(), nidas::core::StatusListener::run(), nidas::core::DSMServerStat::run(), nidas::dynld::UDPSampleOutput::ConnectionMonitor::run(), nidas::dynld::UDPSampleOutput::XMLSocketListener::run(), nidas::util::McSocketListener::run(), nidas::util::McSocketMulticaster< SocketTT >::run(), nidas::dynld::raf::DSMMesaSensor::selectfiletype(), nidas::dynld::raf::DSMMesaSensor::sendFPGACodeToDriver(), nidas::dynld::raf::SppSerial::sendInitPacketAndCheckAck(), nidas::dynld::raf::UHSAS_Serial::sendInitString(), nidas::core::NidasApp::setFileSetTimes(), nidas::util::SocketImpl::setNonBlocking(), nidas::core::NidasApp::setOutputClipping(), nidas::util::SocketImpl::setTcpNoDelay(), nidas::core::Looper::setupClientMaps(), InfluxDB::setUser(), nidas::util::Thread::thr_cleanup(), nidas::dynld::raf::UDPiPMSensor::validate(), nidas::core::DSMEngine::waitForSignal(), nidas::core::DSMServerApp::waitForSignal(), nidas::core::MultipleUDPSockets::write(), nidas::core::MultipleUDPSockets::write(), TeeI2C::writeFilteredOutput(), nidas::core::SampleSorter::~SampleSorter(), and nidas::dynld::raf::SyncRecordSource::~SyncRecordSource().

ILOGT

#define ILOGT	(		TAGS,
			MSG )   LOGGER_LOGPOINT(LOGGER_INFO,TAGS,MSG)

LOG_ALERT

#define LOG_ALERT   LOG_CONTEXT(LOGGER_ALERT)

LOG_CONTEXT

#define LOG_CONTEXT

(

LEVEL

)

nidas::util::LEVEL, __FILE__, __PRETTY_FUNCTION__, __LINE__

LOG_CRIT

#define LOG_CRIT   LOG_CONTEXT(LOGGER_CRIT)

LOG_DEBUG

#define LOG_DEBUG   LOG_CONTEXT(LOGGER_DEBUG)

Referenced by nidas::core::SampleClock::addSampleDate(), nidas::dynld::raf::SyncRecordSource::allocateRecord(), nidas::dynld::raf::IRIGSensor::checkClock(), nidas::dynld::SampleInputStream::closeBlocks(), nidas::core::NidasApp::parseInputs(), NidsMerge::parseRunstring(), StatsProcess::parseRunstring(), nidas::dynld::isff::Wind2D::process(), nidas::dynld::iss::TiltSensor::process(), nidas::util::SocketImpl::receive(), nidas::dynld::SampleInputStream::sampleFromHeader(), nidas::core::CharacterSensor::searchSampleScanners(), nidas::dynld::raf::SyncRecordSource::sendSyncRecord(), and nidas::dynld::isff::NCAR_TRH::validate().

LOG_EMERG

#define LOG_EMERG   LOG_CONTEXT(LOGGER_EMERG)

LOG_ERR

#define LOG_ERR   LOG_CONTEXT(LOGGER_ERR)

Referenced by nidas::core::DSMService::cancel(), nidas::core::DSMService::checkSubThreads(), nidas::dynld::UDPSampleOutput::clone(), nidas::dynld::raf::PPT_Serial::close(), nidas::core::DSMEngine::closeOutputs(), nidas::dynld::raf::SyncRecordSource::computeSlotIndex(), nidas::core::DSMEngine::disconnect(), nidas::core::SampleArchiver::disconnect(), nidas::dynld::raf::CVIProcessor::disconnect(), nidas::dynld::raf::SyncRecordGenerator::disconnect(), nidas::dynld::SampleProcessor::disconnect(), nidas::dynld::StatisticsProcessor::disconnect(), nidas::core::GetAdsFileName::execute(), nidas::core::DSMService::interrupt(), nidas::core::DSMService::join(), nidas::util::McSocket< SocketT >::joinMulticaster(), nidas::core::SerialSensor::Prompter::looperNotify(), nidas::dynld::raf::SyncRecordSource::nextRecord(), nidas::dynld::raf::DSMAnalogSensor::open(), nidas::core::SerialSensor::printStatus(), nidas::dynld::DSC_A2DSensor::printStatus(), nidas::dynld::DSC_Event::printStatus(), nidas::dynld::DSC_FreqCounter::printStatus(), nidas::dynld::DSC_PulseCounter::printStatus(), nidas::dynld::raf::DSMAnalogSensor::printStatus(), nidas::dynld::raf::DSMArincSensor::printStatus(), nidas::dynld::raf::IRIGSensor::printStatus(), nidas::dynld::raf::LamsSensor::printStatus(), nidas::dynld::raf::TwoD_USB::printStatus(), nidas::dynld::raf::DSMMesaSensor::process(), nidas::dynld::UDPSampleOutput::receive(), nidas::dynld::raf::SyncRecordSource::receive(), nidas::dynld::raf::CVIProcessor::receive(), nidas::dynld::AsciiOutput::receive(), nidas::dynld::raf::CVIOutput::receive(), nidas::core::Socket::ConnectionThread::run(), nidas::dynld::RawSampleService::Worker::run(), nidas::dynld::RawSampleService::schedule(), nidas::dynld::UDPSampleOutput::UDPSampleOutput(), nidas::dynld::raf::CVIProcessor::~CVIProcessor(), nidas::core::SampleArchiver::~SampleArchiver(), nidas::dynld::SampleProcessor::~SampleProcessor(), nidas::dynld::StatisticsProcessor::~StatisticsProcessor(), and nidas::dynld::raf::SyncRecordGenerator::~SyncRecordGenerator().

LOG_INFO

#define LOG_INFO   LOG_CONTEXT(LOGGER_INFO)

Referenced by nidas::dynld::raf::IRIGSensor::checkClock(), nidas::core::ServerSocketIODevice::close(), nidas::core::TCPSocketIODevice::close(), nidas::core::UDPSocketIODevice::close(), nidas::core::DSMEngine::connect(), nidas::dynld::isff::MOSMote::MOS_TimeSyncer::looperNotify(), nidas::core::DSMEngine::openSensors(), nidas::dynld::raf::SyncRecordSource::preLoadCalibrations(), nidas::dynld::raf::SyncRecordSource::receive(), nidas::core::Looper::removeClient(), nidas::core::SensorHandler::run(), and nidas::dynld::RawSampleService::Worker::run().

LOG_NOTICE

#define LOG_NOTICE   LOG_CONTEXT(LOGGER_NOTICE)

Referenced by nidas::dynld::raf::DSMAnalogSensor::readFilterFile().

LOG_STATIC_CONTEXT

#define LOG_STATIC_CONTEXT

(

LEVEL

)

nidas::util::LEVEL, __FILE__, "file_static_scope", __LINE__

Expand to LogContext tuple outside function scope.

Use this macro to expand to the LogContext arguments when not inside a function, when PRETTY_FUNCTION is not valid.

LOG_VERBOSE

#define LOG_VERBOSE   LOG_CONTEXT(LOGGER_VERBOSE)

Referenced by nidas::dynld::StatisticsProcessor::addRequestedSampleTag(), nidas::core::TimetagAdjuster::adjust(), nidas::dynld::StatisticsCruncher::attach(), nidas::dynld::StatisticsCruncher::computeStats(), nidas::dynld::StatisticsCruncher::connect(), nidas::core::SamplePipeline::connect(), nidas::dynld::StatisticsProcessor::connectSource(), nidas::dynld::raf::TwoD_Processing::countParticle(), nidas::dynld::StatisticsCruncher::createCombinations(), nidas::core::BadSampleFilter::invalidSampleHeader(), nidas::dynld::raf::TwoD64_USB::process(), nidas::dynld::raf::TwoD64_USB::processImageRecord(), nidas::core::CalFile::readCFInclude(), nidas::dynld::raf::SyncRecordSource::receive(), nidas::dynld::StatisticsCruncher::receive(), DataPrep::run(), nidas::core::SampleSorter::run(), nidas::dynld::StatisticsCruncher::StatisticsCruncher(), and nidas::dynld::SampleOutputStream::write().

LOG_WARNING

#define LOG_WARNING   LOG_CONTEXT(LOGGER_WARNING)

Referenced by nidas::core::DSMSensor::addSampleTag(), nidas::dynld::raf::IRIGSensor::checkClock(), nidas::dynld::SampleInputStream::closeBlocks(), nidas::dynld::raf::AlicatSDI::derivedDataNotify(), nidas::dynld::raf::PIP_Serial::derivedDataNotify(), nidas::dynld::raf::TwoD_USB::derivedDataNotify(), nidas::dynld::raf::VCSEL2_Serial::derivedDataNotify(), nidas::dynld::raf::VCSEL_Serial::derivedDataNotify(), nidas::core::RemoteSerialConnection::doEscCmds(), nidas::core::DSMConfig::fromDOMElement(), nidas::core::DSMSensor::fromDOMElement(), nidas::core::McSocket::fromDOMElement(), nidas::core::McSocketUDP::fromDOMElement(), nidas::core::MultipleUDPSockets::fromDOMElement(), nidas::core::DSMService::fromDOMElement(), nidas::core::DSMSensor::getLooper(), nidas::core::Socket::getRemoteInet4Address(), nidas::dynld::raf::TwoD64_USB::init_parameters(), nidas::dynld::isff::MOSMote::MOS_TimeSyncer::looperNotify(), nidas::dynld::raf::AlicatSDI::open(), nidas::dynld::raf::LamsSensor::open(), nidas::dynld::raf::PIP_Serial::open(), nidas::dynld::raf::TwoD_USB::open(), nidas::dynld::raf::VCSEL2_Serial::open(), nidas::dynld::raf::VCSEL_Serial::open(), nidas::dynld::raf::DSMAnalogSensor::process(), nidas::dynld::A2DSensor::process(), nidas::dynld::raf::A2D_Serial::process(), nidas::dynld::raf::PSI9116_Sensor::process(), nidas::core::DatagramSampleScanner::readBuffer(), nidas::core::A2DConverter::readCalFile(), nidas::dynld::ParoSci_202BG_Calibration::readCalFile(), nidas::dynld::isff::Wind3D::readOffsetsAnglesCalFile(), nidas::dynld::UDPSampleOutput::receive(), nidas::dynld::raf::SyncRecordSource::receive(), SensorExtract::run(), nidas::core::SensorHandler::run(), nidas::dynld::SampleInputStream::sampleFromHeader(), nidas::dynld::raf::SyncRecordSource::selectVariablesFromSensor(), nidas::dynld::raf::TwoD_USB::sendTrueAirspeed(), nidas::dynld::raf::A2D_Serial::validate(), nidas::core::CharacterSensor::validateSscanfs(), and nidas::core::ServerSocket::~ServerSocket().

LOGGER_LOGPOINT

#define LOGGER_LOGPOINT	(		LEVEL,
			TAGS,
			MSG )

Value:

    do {                                                                \
        nidas::util::Logger::init();                                    \
        static NIDAS_LOGGER_THREADLOCAL nidas::util::LogContext logctxt \
            (nidas::util::LEVEL, __FILE__,__PRETTY_FUNCTION__,          \
             __LINE__,TAGS);                                            \
        if (logctxt.active())                                           \
            logctxt.log(nidas::util::LogMessage().format MSG); }        \
    while (0)

This macro creates a static LogContext instance that is not in thread-local storage and therefore is not thread-safe.

The active flag will be written from any thread which changes the log configuration, and reads of the active flag happen in all threads which execute this log point. TLS was implemented at one point, but it turned out not to be portable enough. Locking is not really warranted given that in practice logging configurations do not change during runtime.

If thread-safety is required, then an automatic lock can be added to the beginning of the do-while block. I don't think the static initialization needs to happen inside the lock, at least for GCC. GCC already guards static initialization, but helgrind or DRD may not be able to recognize that without surrounding the block with a pthread lock. The actual check of the active flag probably should be thread-safe, since presumably one thread will initially write it and then multiple threads will read it. If the write happens inside the guard and only reads happen outside, then maybe that's safe enough since the reconfiguration of running log points does not happen in practice.

The lock used cannot be the global logging lock unless it is unlocked before calling the log() method, since the global lock is locked by the log() method and the lock is not recurisve. One goal for all this is to make things look reasonable and consistent to program checkers like helgrind.

The VERBOSE log level is intended for very verbose log messages which typically would only be used by developers. They are never enabled by a default LogConfig, they are above the DEBUG threshold, and in practice their overhead should be minimized by testing whether the log point is active() before generating any log output. It should be safe to compile them into code, and that should be preferred over surrounding them in a pre-processor conditional compilation block.

NLOG

#define NLOG

(

MSG

)

LOGGER_LOGPOINT(LOGGER_NOTICE,"",MSG)

Referenced by nidas::util::SocketImpl::accept(), nidas::core::SensorHandler::add(), nidas::dynld::isff::WisardMote::checkCRC(), nidas::dynld::isff::WisardMote::checkEOM(), nidas::core::DSMSensor::close(), nidas::dynld::XMLConfigService::connected(), nidas::core::SensorHandler::PolledDSMSensor::handlePollEvents(), main(), nidas::core::DSMSensor::open(), nidas::core::XMLParser::parse(), nidas::core::DSMServerApp::parseXMLConfigFile(), nidas::dynld::raf::IRIGSensor::printStatus(), nidas::dynld::isff::CSI_CRX_Binary::process(), nidas::core::SampleScanner::readBuffer(), nidas::dynld::SampleOutputStream::receive(), nidas::core::DerivedDataReader::run(), nidas::core::SampleSorter::run(), nidas::dynld::raf::PSI9116_Sensor::sendCommand(), nidas::dynld::raf::DSMMesaSensor::sendFPGACodeToDriver(), sigAction(), TeeI2C::writeFilteredOutput(), TeeI2C::writeOutput(), and nidas::core::RemoteSerialConnection::~RemoteSerialConnection().

NLOGT

#define NLOGT	(		TAGS,
			MSG )   LOGGER_LOGPOINT(LOGGER_NOTICE,TAGS,MSG)

PLOG

#define PLOG

(

MSG

)

LOGGER_LOGPOINT(LOGGER_ERR,"",MSG)

Referenced by nidas::core::SensorHandler::add(), nidas::core::SensorHandler::add(), nidas::core::FsMount::cancel(), nidas::core::NidasApp::checkPidFile(), nidas::dynld::UDPSampleOutput::XMLSocketListener::checkWorkers(), nidas::dynld::XMLConfigService::connected(), nidas::dynld::StatisticsProcessor::connectSource(), nidas::core::DerivedDataReader::deleteInstance(), nidas::core::StatusHandler::error(), nidas::core::DSMEngineIntf::DSMAction::execute(), nidas::core::DSMEngineIntf::SensorAction::execute(), nidas::dynld::DSC_A2DSensor::executeXmlRpc(), nidas::dynld::raf::A2D_Serial::executeXmlRpc(), nidas::dynld::raf::DSMAnalogSensor::executeXmlRpc(), nidas::dynld::raf::PSI9116_Sensor::executeXmlRpc(), nidas::core::StatusHandler::fatalError(), nidas::dynld::UDPSampleOutput::XMLSocketListener::fireWorkers(), nidas::dynld::raf::DSMMesaSensor::fromDOMElement(), nidas::dynld::raf::DSMAnalogSensor::getA2DSetup(), nidas::core::NidasApp::getHostName(), StatsProcess::getStatisticsProcessor(), nidas::core::Project::getUniqueSampleId(), nidas::core::RemoteSerialConnection::handlePollEvents(), nidas::core::RemoteSerialListener::handlePollEvents(), nidas::core::SensorHandler::PolledDSMSensor::handlePollEvents(), nidas::core::SensorHandler::NotifyPipe::handlePollEvents(), nidas::util::McSocketListener::interrupt(), nidas::util::McSocketMulticaster< SocketTT >::interrupt(), nidas::core::DSMEngine::joinDataThreads(), StatsProcess::listOutputSamples(), PacketReader::loop(), main(), nidas::core::DSMEngine::main(), nidas::core::DSMServerApp::main(), nidas::dynld::isff::CSAT3_Sonic::open(), nidas::dynld::raf::UDPArincSensor::open(), nidas::dynld::raf::UDPiPMSensor::open(), nidas::dynld::SampleInputStream::parseInputHeader(), nidas::dynld::iss::TiltSensor::process(), nidas::dynld::isff::DAUSensor::process(), nidas::core::SensorHandler::remove(), nidas::core::SensorHandler::remove(), nidas::core::requestXMLConfig(), DataPrep::run(), ServerThread::run(), StatsProcess::run(), TeeI2C::run(), TeeTTy::run(), nidas::core::DerivedDataReader::run(), nidas::core::DSMEngine::run(), nidas::core::DSMServerApp::run(), nidas::core::FsMountWorkerThread::run(), nidas::core::SampleOutputRequestThread::run(), nidas::core::SensorHandler::run(), nidas::core::SensorOpener::run(), nidas::core::StatusListener::run(), nidas::dynld::XMLConfigService::Worker::run(), nidas::util::ThreadJoiner::run(), nidas::core::FileSet::setNonBlocking(), nidas::core::StatusListener::StatusListener(), nidas::dynld::DSC_A2DSensor::testVoltage(), nidas::dynld::raf::A2D_Serial::testVoltage(), nidas::dynld::raf::DSMAnalogSensor::testVoltage(), nidas::core::DSMEngine::waitForSignal(), nidas::core::DSMServerApp::waitForSignal(), nidas::core::SensorHandler::NotifyPipe::~NotifyPipe(), nidas::core::RemoteSerialListener::~RemoteSerialListener(), and nidas::util::Thread::~Thread().

PLOGT

#define PLOGT	(		TAGS,
			MSG )   LOGGER_LOGPOINT(LOGGER_ERR,TAGS,MSG)

VLOG

#define VLOG

(

MSG

)

LOGGER_LOGPOINT(LOGGER_VERBOSE,"",MSG)

Referenced by nidas::util::SocketImpl::accept(), nidas::util::McSocket< SocketT >::accept(), nidas::util::McSocketListener::accept(), nidas::util::McSocketListener::accept(), nidas::util::McSocketListener::add(), nidas::core::SampleOutputRequestThread::addConnectRequest(), InfluxDB::addMeasurement(), nidas::dynld::isff::WisardMote::addMoteSampleTag(), nidas::dynld::StatisticsProcessor::addRequestedSampleTag(), nidas::core::SamplePipeline::addSampleClient(), nidas::dynld::StatisticsCruncher::attach(), CharBuffer::CharBuffer(), TeeI2C::checkNMEA(), nidas::util::UTime::checkParse(), nidas::dynld::SampleOutputStream::close(), nidas::util::McSocket< SocketT >::close(), nidas::util::SocketImpl::close(), nidas::util::McSocketListener::close(), nidas::util::McSocketListener::close(), nidas::util::McSocket< SocketT >::connect(), nidas::dynld::RawSampleService::connect(), nidas::core::SampleArchiver::connect(), nidas::dynld::StatisticsCruncher::connect(), nidas::dynld::StatisticsProcessor::connectSource(), nidas::dynld::StatisticsCruncher::createCombinations(), nidas::dynld::RawSampleService::disconnect(), nidas::core::Dictionary::expandString(), nidas::core::Site::findDSM(), nidas::core::Site::findDSM(), nidas::core::Site::findSensor(), SampleDispatcher::findStats(), nidas::core::SampleSorter::flush(), nidas::dynld::SampleInputStream::flush(), nidas::dynld::SampleOutputStream::flush(), nidas::util::SocketImpl::getInterface(), nidas::util::SocketImpl::getInterface(), nidas::util::SocketImpl::getInterfaces(), nidas::util::SocketImpl::getLocalAddr(), nidas::util::SocketImpl::getReceiveBufferSize(), nidas::util::SocketImpl::getRemoteAddr(), nidas::util::SocketImpl::getSendBufferSize(), StatsProcess::getStatisticsProcessor(), nidas::dynld::SampleInputStream::handleNewInput(), DataStats::hashId(), nidas::util::SocketImpl::joinGroup(), nidas::util::McSocket< SocketT >::joinMulticaster(), nidas::util::listMulticastInterfaces(), PacketReader::loop(), DataPrep::matchVariables(), nidas::core::NearestResamplerAtRate::NearestResamplerAtRate(), nidas::dynld::SampleInputStream::nextSample(), CharBuffer::operator=(), nidas::util::EndianConverter::privGetHostEndianness(), nidas::dynld::isff::WisardMote::process(), nidas::dynld::isff::CSAT3_Sonic::process(), nidas::core::SamplePipeline::procinit(), nidas::core::SamplePipeline::rawinit(), nidas::core::IOStream::read(), nidas::dynld::SampleInputStream::read(), nidas::core::CalFile::readCFInclude(), nidas::dynld::isff::WisardMote::readHead(), nidas::core::CalFile::readLine(), nidas::dynld::SampleInputStream::readSamples(), nidas::core::IOStream::reallocateBuffer(), nidas::dynld::SampleOutputStream::receive(), SampleDispatcher::receive(), SampleCounter::receive(), DataStats::receive(), nidas::util::McSocketListener::remove(), nidas::util::McSocketListener::remove(), nidas::core::Project::removeAutoConfig(), DataPrep::run(), WriterThread::run(), nidas::core::Looper::run(), nidas::util::McSocketListener::run(), nidas::util::McSocketMulticaster< SocketTT >::run(), nidas::dynld::WxtSensor::scanSample(), nidas::util::SocketImpl::send(), nidas::core::StatusThread::sendStatus(), nidas::core::CalFile::setDateTimeFormat(), nidas::util::SocketImpl::setInterface(), nidas::core::CalFile::setTimeZone(), nidas::dynld::isff::WisardMote::unpackAccumSec(), nidas::dynld::isff::WisardMote::validate(), TeeI2C::writeOutput(), nidas::core::SampleBuffer::~SampleBuffer(), nidas::dynld::SampleOutputStream::~SampleOutputStream(), and nidas::core::SampleSorter::~SampleSorter().

VLOGT

#define VLOGT	(		TAGS,
			MSG )   LOGGER_LOGPOINT(LOGGER_VERBOSE,TAGS,MSG)

Referenced by nidas::dynld::StatisticsProcessor::connectSource().

WLOG

#define WLOG

(

MSG

)

LOGGER_LOGPOINT(LOGGER_WARNING,"",MSG)

Referenced by nidas::core::VariableConverter::abortCalFile(), nidas::dynld::UDPSampleOutput::ConnectionMonitor::addConnection(), nidas::dynld::isff::WisardMote::addMoteSampleTag(), nidas::dynld::StatisticsCruncher::attach(), nidas::core::IOStream::backup(), nidas::util::SocketImpl::bind(), nidas::dynld::raf::A2D_Serial::checkCkSum(), nidas::dynld::isff::WisardMote::checkCRC(), nidas::dynld::raf::Watlow::checkCRC(), nidas::dynld::isff::WisardMote::checkEOM(), nidas::core::SensorHandler::PolledDSMSensor::checkTimeout(), nidas::dynld::SampleInputStream::checkUnexpectedEOF(), nidas::dynld::RawSampleService::connect(), nidas::core::SampleArchiver::connect(), nidas::core::NearestResamplerAtRate::connect(), nidas::core::SampleAverager::connect(), nidas::dynld::StatisticsCruncher::connect(), nidas::core::NearestResampler::connect(), nidas::dynld::XMLConfigService::connected(), nidas::dynld::UDPSampleOutput::connected(), nidas::util::FileSet::createFile(), nidas::dynld::raf::SyncRecordSource::createHeader(), nidas::dynld::isff::WisardMote::createSampleTag(), nidas::dynld::raf::LamsSensor::derivedDataNotify(), nidas::core::SampleOutputRequestThread::destroyInstance(), nidas::dynld::RawSampleService::disconnect(), nidas::core::Project::findDSM(), nidas::core::Project::findDSM(), nidas::core::Project::findServerSampleOutputStreamFileSets(), nidas::core::SampleSorter::flush(), nidas::dynld::SampleOutputStream::flush(), nidas::core::DatagramSocket::fromDOMElement(), nidas::core::DSMConfig::fromDOMElement(), nidas::core::Socket::fromDOMElement(), nidas::core::Variable::fromDOMElement(), nidas::core::SampleIOProcessor::fromDOMElement(), nidas::core::SampleOutputBase::fromDOMElement(), nidas::dynld::SampleInputStream::fromDOMElement(), nidas::core::NidasApp::getDataset(), nidas::util::Inet4Address::getHostName(), nidas::core::MultipleUDPSockets::handleChangedSockets(), nidas::core::SensorHandler::PolledDSMSensor::handlePollEvents(), nidas::dynld::raf::DSMArincSensor::init(), nidas::core::DerivedDataReader::interrupt(), nidas::core::SensorOpener::interrupt(), nidas::core::XmlRpcThread::interrupt(), nidas::core::SamplePipeline::join(), nidas::core::DSMEngine::joinDataThreads(), nidas::core::DSMServerApp::killStatusThread(), nidas::core::DSMEngine::killXmlRpcThread(), nidas::core::DSMServerApp::killXmlRpcThread(), nidas::core::NidasApp::lockMemory(), PacketReader::logBadPacket(), nidas::dynld::SampleInputStream::nextSample(), nidas::core::SensorHandler::NotifyPipe::notify(), nidas::dynld::isff::CSAT3_Sonic::open(), nidas::dynld::raf::A2D_Serial::parseConfigLine(), nidas::core::Polynomial::parseFields(), nidas::dynld::isff::CSI_IRGA_Sonic::parseParameters(), nidas::dynld::raf::DSMArincSensor::process(), nidas::dynld::isff::WisardMote::process(), nidas::dynld::GPS_NMEA_Serial::process(), nidas::dynld::GPS_Novatel_Serial::process(), nidas::dynld::ModbusRTU::process(), nidas::dynld::raf::LamsNetSensor::process(), nidas::dynld::raf::PPT_Serial::process(), nidas::dynld::raf::UDPArincSensor::process(), nidas::dynld::raf::UHSAS_Serial::process(), nidas::dynld::raf::Watlow::process(), nidas::dynld::raf::DSMArincSensor::processAlta(), nidas::dynld::raf::TwoD32_USB::processImage(), nidas::dynld::raf::TwoD64_USB::processImageRecord(), nidas::dynld::raf::A2D_Serial::readConfig(), nidas::dynld::isff::WisardMote::readHead(), nidas::core::NearestResampler::receive(), nidas::core::NearestResamplerAtRate::receive(), nidas::core::SampleSorter::receive(), nidas::dynld::SampleOutputStream::receive(), nidas::dynld::StatisticsCruncher::receive(), SampleDispatcher::receive(), nidas::util::SocketImpl::receive(), nidas::core::SensorHandler::remove(), nidas::dynld::UDPSampleOutput::ConnectionMonitor::removeConnection(), nidas::dynld::isff::CU_Coldwire::reportBadChecksum(), nidas::dynld::isff::CSI_CRX_Binary::reportBadCRC(), nidas::dynld::isff::CSI_IRGA_Sonic::reportBadCRC(), DataPrep::run(), WriterThread::run(), ServerThread::run(), StatsProcess::run(), TeeI2C::run(), TeeTTy::run(), nidas::core::DerivedDataReader::run(), nidas::core::SampleBuffer::run(), nidas::core::SampleSorter::run(), nidas::core::SensorOpener::run(), nidas::core::DSMEngineStat::run(), nidas::core::DSMServerStat::run(), nidas::dynld::RawSampleService::Worker::run(), nidas::util::McSocketListener::run(), nidas::util::McSocketMulticaster< SocketTT >::run(), nidas::dynld::SampleInputStream::sampleFromHeader(), SampleToDatabase::SampleToDatabase(), nidas::dynld::WxtSensor::scanSample(), nidas::core::RemoteSerialConnection::sensorNotFound(), TeeI2C::setFIFOPriority(), TeeTTy::setFIFOPriority(), nidas::util::Thread::setThreadSchedulerNolock(), nidas::core::NidasApp::setupProcess(), nidas::dynld::isff::CSAT3_Sonic::terminalMode(), nidas::dynld::raf::A2D_Serial::validate(), nidas::core::DSMEngine::waitForSignal(), nidas::core::DSMServerApp::waitForSignal(), nidas::core::MessageStreamScanner::warnBackwardsStepTimeTag(), nidas::core::StatusHandler::warning(), nidas::core::MessageStreamScanner::warnNonIncrTimeTag(), nidas::core::IOStream::write(), TeeI2C::writeFilteredOutput(), TeeI2C::writeOutput(), nidas::dynld::WxtSensor::wxtValidateSscanfs(), nidas::dynld::XMLConfigAllService::XMLConfigAllService(), nidas::core::DatagramSocket::~DatagramSocket(), nidas::core::SampleBuffer::~SampleBuffer(), nidas::core::SampleSorter::~SampleSorter(), and nidas::core::Socket::~Socket().

WLOGT

#define WLOGT	(		TAGS,
			MSG )   LOGGER_LOGPOINT(LOGGER_WARNING,TAGS,MSG)

Function Documentation

endlog()

LogMessage & nidas::util::endlog ( LogMessage & logmsg )

inline

LogMessage manipulator which logs the current message buffer, if any, and then clears the message.

References nidas::util::LogMessage::log().

Referenced by nidas::dynld::raf::TwoD_Processing::countParticle().

getParameterT()

template<typename T >

T nidas::util::LogScheme::getParameterT	(	const std::string &	name,
		const T &	dvalue = T() )

Lookup a parameter with name name in a LogScheme and convert the value to the type of the dvalue parameter.

If the parameter has not been set in this LogScheme or cannot be converted, then return dvalue.

Below is an example of using a log parameter to throttle the frequency of a log message. The first section retrieves the value from the currently active LogScheme, the second logs the message.

_discardWarningCount = 1000;
_discardWarningCount =
  Logger::getScheme().getParameterT("_discard_warning_count",
                                    _discardWarningCount);

Then use the parameter value like so:

if (!(_discardedSamples++ % _discardWarningCount))
    WLOG(("%d samples discarded... ", _discardedSamples));

See the NidasApp class 'logparam' option to set a LogScheme parameter on the command-line.

References nidas::util::LogScheme::getParameter().

log() [1/2]

LogMessage nidas::util::LogContextState::log ( ) const

inline

Return a LogMessage associated with this LogContextState, so the message will be logged through this context when the LogMessage goes out of scope.

Typically this is used as a temporary object to which the log message content can be streamed, which can be a little more convenient than formatting the message separately and then passing it to log(const std::string& msg). Also see the LogMessage() constructor which takes a LogContext.

static LogContext lp(LOG_INFO);
if (lp.active())
{
    lp.log() << "complicated info output...";
}

log() [2/2]

void nidas::util::LogContextState::log ( const std::string & msg ) const

inline

Convenience method which writes the given message to the current Logger instance, passing this object as the LogContextState.

Normally this method is called from a LogContext:

static LogContext lp(LOG_INFO);
if (lp.active())
{
    LogMessage msg;
    msg << "complicated info output...";
    lp.log(msg);
}

References nidas::util::Logger::getInstance().

Referenced by nidas::dynld::SampleInputStream::closeBlocks(), and nidas::dynld::SampleInputStream::sampleFromHeader().

logLevelToString()

std::string nidas::util::logLevelToString

(

int

)

Convert an integral log level to a string name.

Returns

The name for the given log level, or else "emergency".

Referenced by nidas::util::LogContextState::levelName().

operator<<() [1/2]

template<typename T >

LogMessage & nidas::util::LogMessage::operator<< ( const T & t )

inline

Everything streamed to a LogMessage is passed on to the underlying ostringstream, including ostream manipulators.

References nidas::util::LogMessage::msg.

operator<<() [2/2]

LogMessage & nidas::util::operator<< ( LogMessage & logmsg, LogMessage &(*)(LogMessage &) op )

inline

Template to call LogMessage manipulators like endlog when streamed to a LogMessage.

stringToLogLevel()

int nidas::util::stringToLogLevel

(

const std::string &

slevel

)

Convert the name of a log level to its integer value.

Returns

The log level value, or -1 if the name is not recognized.

References nidas::util::LOGGER_NONE, and nidas::util::LOGGER_WARNING.

Referenced by LogSchemeFromDOMElement(), and parse_log_level().

Variable Documentation

LOGGER_ALERT

const int nidas::util::LOGGER_ALERT = LOG_ALERT

LOGGER_CRIT

const int nidas::util::LOGGER_CRIT = LOG_CRIT

LOGGER_CRITICAL

const int nidas::util::LOGGER_CRITICAL = LOG_CRIT

LOGGER_DEBUG

const int nidas::util::LOGGER_DEBUG = LOG_DEBUG

Referenced by main().

LOGGER_EMERGENCY

const int nidas::util::LOGGER_EMERGENCY = LOG_EMERG

LOGGER_ERR

const int nidas::util::LOGGER_ERR = LOG_ERR

LOGGER_ERROR

const int nidas::util::LOGGER_ERROR = LOG_ERR

LOGGER_INFO

const int nidas::util::LOGGER_INFO = LOG_INFO

Referenced by main(), nidas::core::NidasApp::setupLogScheme(), nidas::dynld::isff::ATIK_Sonic::~ATIK_Sonic(), nidas::core::CharacterSensor::~CharacterSensor(), nidas::dynld::isff::CSAT3_Sonic::~CSAT3_Sonic(), nidas::dynld::isff::CSI_CRX_Binary::~CSI_CRX_Binary(), nidas::dynld::isff::CSI_IRGA_Sonic::~CSI_IRGA_Sonic(), and nidas::dynld::raf::DSMArincSensor::~DSMArincSensor().

LOGGER_NONE

const int nidas::util::LOGGER_NONE = LOG_EMERG-1

Referenced by nidas::util::LogScheme::logLevel(), parse_log_level(), and nidas::util::stringToLogLevel().

LOGGER_NOTICE

const int nidas::util::LOGGER_NOTICE = LOG_NOTICE

LOGGER_PROBLEM

const int nidas::util::LOGGER_PROBLEM = LOG_ERR

LOGGER_VERBOSE

const int nidas::util::LOGGER_VERBOSE = LOG_DEBUG+1

Referenced by nidas::util::Logger::msg(), and parse_log_level().

LOGGER_WARNING

const int nidas::util::LOGGER_WARNING = LOG_WARNING

Referenced by get_scheme(), main(), and nidas::util::stringToLogLevel().