Log Class Reference

Global static Log class. More...

#include <ored/utilities/log.hpp>

Inheritance diagram for Log:

Collaboration diagram for Log:

Public Member Functions
void	registerLogger (const QuantLib::ext::shared_ptr< Logger > &logger)
	Add a new Logger. More...
void	registerIndependentLogger (const QuantLib::ext::shared_ptr< IndependentLogger > &logger)
void	clearAllIndependentLoggers ()
const bool	hasLogger (const std::string &name) const
	Check if logger exists. More...
const bool	hasIndependentLogger (const std::string &name) const
QuantLib::ext::shared_ptr< Logger > &	logger (const std::string &name)
	Retrieve a Logger. More...
QuantLib::ext::shared_ptr< IndependentLogger > &	independentLogger (const std::string &name)
void	removeLogger (const std::string &name)
	Remove a Logger. More...
void	removeIndependentLogger (const std::string &name)
void	removeAllLoggers ()
	Remove all loggers. More...
void	addExcludeFilter (const std::string &, const std::function< bool(const std::string &)>)
void	removeExcludeFilter (const std::string &)
bool	checkExcludeFilters (const std::string &)
void	header (unsigned m, const char *filename, int lineNo)
	macro utility function - do not use directly, not thread safe More...
std::ostream &	logStream ()
	macro utility function - do not use directly, not thread safe More...
void	log (unsigned m)
	macro utility function - do not use directly, not thread safe More...
boost::shared_mutex &	mutex ()
	mutex to acquire locks More...
bool	filter (unsigned mask)
unsigned	mask ()
void	setMask (unsigned mask)
const boost::filesystem::path &	rootPath ()
void	setRootPath (const boost::filesystem::path &pth)
int	maxLen ()
void	setMaxLen (const int n)
bool	enabled ()
void	switchOn ()
void	switchOff ()
bool	writeSuppressedMessagesHint ()
void	setPid (const int pid)
	if a PID is set for the logger, messages are tagged with [1234] if pid = 1234 More...

Private Member Functions
	Log ()
std::string	source (const char *filename, int lineNo) const

Private Attributes
std::map< std::string, QuantLib::ext::shared_ptr< Logger > >	loggers_
std::map< std::string, QuantLib::ext::shared_ptr< IndependentLogger > >	independentLoggers_
bool	enabled_
unsigned	mask_
boost::filesystem::path	rootPath_
std::ostringstream	ls_
int	maxLen_ = 45
std::size_t	sameSourceLocationSince_ = 0
bool	writeSuppressedMessagesHint_ = true
std::size_t	sameSourceLocationCutoff_ = 1000
std::string	lastFileName_
int	lastLineNo_ = 0
int	pid_ = 0
boost::shared_mutex	mutex_
std::map< std::string, std::function< bool(const std::string &)> >	excludeFilters_

Friends
class	QuantLib::Singleton< Log, std::integral_constant< bool, true > >

Detailed Description

Global static Log class.

The Global Log class gets registered with individual loggers and receives application log messages. Once a message is received, it is immediately dispatched to each of the registered loggers, the order in which the loggers are called is not guaranteed.

Logging is done by the calling thread and the LOG call blocks until all the loggers have returned.

At start up, the Log class has no loggers and so will ignore any LOG() messages until it is configured.

To configure the Log class to log to a file "/tmp/my_log.txt"

    Log::instance().removeAllLoggers();
    Log::instance().registerLogger(QuantLib::ext::shared_ptr<Logger>(new FileLogger("/tmp/my_log.txt")));

To change the Log class to only use a BufferLogger the user must call

    Log::instance().removeAllLoggers();
    Log::instance().registerLogger(QuantLib::ext::shared_ptr<Logger>(new BufferLogger));

and then to retrieve log messages from the buffer and print them to stdout the user must call:

    std::cout << "Begin Log Messages:" << std::endl;

    QuantLib::ext::shared_ptr<BufferLogger> bl = QuantLib::ext::dynamic_pointer_cast<BufferLogger>
      (Log::instance().logger(BufferLogger::name));

    while (bl.hasNext())
        std::cout << bl.next() << std::endl;
    std::cout << "End Log Messages." << std::endl;

Definition at line 389 of file log.hpp.

Constructor & Destructor Documentation

Log()

Log ( )

private

Definition at line 272 of file log.cpp.

         : loggers_(), enabled_(false), mask_(255), ls_() {
 
    ls_.setf(ios::fixed, ios::floatfield);
    ls_.setf(ios::showpoint);
}

Member Function Documentation

registerLogger()

void registerLogger

(

const QuantLib::ext::shared_ptr< Logger > &

logger

)

Add a new Logger.

Adds a new logger to the Log class, the logger will be stored by it's Logger::name(). This method will throw if a logger with the same name is already registered.

Parameters

logger

the logger to add

Definition at line 278 of file log.cpp.

                                                                    {
    boost::unique_lock<boost::shared_mutex> lock(mutex_);
    QL_REQUIRE(loggers_.find(logger->name()) == loggers_.end(),
               "Logger with name " << logger->name() << " already registered");
    loggers_[logger->name()] = logger;
}

Here is the call graph for this function:

registerIndependentLogger()

void registerIndependentLogger

(

const QuantLib::ext::shared_ptr< IndependentLogger > &

logger

)

Definition at line 285 of file log.cpp.

                                                                                          {
    boost::unique_lock<boost::shared_mutex> lock(mutex_);
    QL_REQUIRE(independentLoggers_.find(logger->name()) == independentLoggers_.end(),
               "Logger with name " << logger->name() << " already registered as independent logger");
    independentLoggers_[logger->name()] = logger;
}

Here is the call graph for this function:

clearAllIndependentLoggers()

void clearAllIndependentLoggers

(

)

Definition at line 292 of file log.cpp.

                                     {
    boost::unique_lock<boost::shared_mutex> lock(mutex_);
    for (auto& [_, l] : independentLoggers_)
        l->clear();
}

hasLogger()

const bool hasLogger

(

const std::string &

name

)

const

Check if logger exists.

Definition at line 298 of file log.cpp.

                                                  {
    boost::shared_lock<boost::shared_mutex> lock(mutex_);
    return loggers_.find(name) != loggers_.end();
}

Here is the caller graph for this function:

hasIndependentLogger()

const bool hasIndependentLogger

(

const std::string &

name

)

const

Definition at line 309 of file log.cpp.

                                                             {
    boost::shared_lock<boost::shared_mutex> lock(mutex_);
    return independentLoggers_.find(name) != independentLoggers_.end();
}

Here is the caller graph for this function:

logger()

QuantLib::ext::shared_ptr< Logger > & logger

(

const std::string &

name

)

Retrieve a Logger.

Retrieve a Logger by it's name, for example to retrieve the StderrLogger (assuming it is registered)

QuantLib::ext::shared_ptr<Logger> slogger = Log::instance().logger(StderrLogger::name);

Definition at line 303 of file log.cpp.

                                                             {
    boost::shared_lock<boost::shared_mutex> lock(mutex_);
    QL_REQUIRE(hasLogger(name), "No logger found with name " << name);
    return loggers_[name];
}

Here is the call graph for this function:

Here is the caller graph for this function:

independentLogger()

QuantLib::ext::shared_ptr< IndependentLogger > & independentLogger

(

const std::string &

name

)

Definition at line 314 of file log.cpp.

                                                                                   {
    boost::shared_lock<boost::shared_mutex> lock(mutex_);
    QL_REQUIRE(hasIndependentLogger(name), "No independent logger found with name " << name);
    return independentLoggers_[name];
}

Here is the call graph for this function:

removeLogger()

void removeLogger

(

const std::string &

name

)

Remove a Logger.

Remove a logger by name

Parameters

name	the logger name

Definition at line 320 of file log.cpp.

                                         {
    boost::unique_lock<boost::shared_mutex> lock(mutex_);
    map<string, QuantLib::ext::shared_ptr<Logger>>::iterator it = loggers_.find(name);
    if (it != loggers_.end()) {
        loggers_.erase(it);
    } else {
        QL_FAIL("No logger found with name " << name);
    }
}

removeIndependentLogger()

void removeIndependentLogger

(

const std::string &

name

)

Definition at line 330 of file log.cpp.

                                                    {
    boost::unique_lock<boost::shared_mutex> lock(mutex_);
    map<string, QuantLib::ext::shared_ptr<IndependentLogger>>::iterator it = independentLoggers_.find(name);
    if (it != independentLoggers_.end()) {
        it->second->removeSinks();
        independentLoggers_.erase(it);
    } else {
        QL_FAIL("No independdent logger found with name " << name);
    }
}

removeAllLoggers()

void removeAllLoggers

(

)

Remove all loggers.

Removes all loggers. If called, all subsequent log messages will be ignored.

Definition at line 341 of file log.cpp.

                           {
    boost::unique_lock<boost::shared_mutex> lock(mutex_);
    loggers_.clear();
    logging::core::get()->remove_all_sinks();
    independentLoggers_.clear();
}

addExcludeFilter()

void addExcludeFilter	(	const std::string &	key,
		const std::function< bool(const std::string &)>	func
	)

Definition at line 372 of file log.cpp.

                                                                                            {
    boost::unique_lock<boost::shared_mutex> lock(mutex_);
    excludeFilters_[key] = func;
}

removeExcludeFilter()

void removeExcludeFilter

(

const std::string &

key

)

Definition at line 377 of file log.cpp.

                                               {
    boost::unique_lock<boost::shared_mutex> lock(mutex_);
    excludeFilters_.erase(key);
}

checkExcludeFilters()

bool checkExcludeFilters

(

const std::string &

msg

)

Definition at line 382 of file log.cpp.

                                                  {
    boost::shared_lock<boost::shared_mutex> lock(mutex_);
    for (const auto& f : excludeFilters_) {
        if (f.second(msg))
            return true;
    }
    return false;
}

header()

void header	(	unsigned	m,
		const char *	filename,
		int	lineNo
	)

macro utility function - do not use directly, not thread safe

Definition at line 391 of file log.cpp.

                                                             {
    // 1. Reset stringstream
    ls_.str(string());
    ls_.clear();
 
    // Write the header to the stream
    // TYPE [Time Stamp] (file:line)
    switch (m) {
    case ORE_ALERT:
        ls_ << "ALERT    ";
        break;
    case ORE_CRITICAL:
        ls_ << "CRITICAL ";
        break;
    case ORE_ERROR:
        ls_ << "ERROR    ";
        break;
    case ORE_WARNING:
        ls_ << "WARNING  ";
        break;
    case ORE_NOTICE:
        ls_ << "NOTICE   ";
        break;
    case ORE_DEBUG:
        ls_ << "DEBUG    ";
        break;
    case ORE_DATA:
        ls_ << "DATA     ";
        break;
    case ORE_MEMORY:
        ls_ << "MEMORY   ";
        break;
    }
 
    // Timestamp
    // Use boost::posix_time microsecond clock to get better precision (when available).
    // format is "2014-Apr-04 11:10:16.179347"
    ls_ << '[' << to_simple_string(microsec_clock::local_time()) << ']';
 
    // Filename & line no
    // format is " (file:line)"
    ls_ << "  " << source(filename, lineNo) << " : ";
 
    // log pid if given
    if (pid_ > 0)
        ls_ << " [" << pid_ << "] ";
 
    // update statistics
    if (lastLineNo_ == lineNo && lastFileName_ == filename) {
        ++sameSourceLocationSince_;
    } else {
        lastFileName_ = filename;
        lastLineNo_ = lineNo;
        sameSourceLocationSince_ = 0;
        writeSuppressedMessagesHint_ = true;
    }
}

Here is the call graph for this function:

logStream()

std::ostream & logStream

(

)

macro utility function - do not use directly, not thread safe

Definition at line 441 of file log.hpp.

{ return ls_; }

log()

void log

(

unsigned

m

)

macro utility function - do not use directly, not thread safe

Definition at line 449 of file log.cpp.

                        {
    string msg = ls_.str();
    map<string, QuantLib::ext::shared_ptr<Logger>>::iterator it;
    if (sameSourceLocationSince_ <= sameSourceLocationCutoff_) {
        for (auto& l : loggers_) {
            l.second->log(m, msg);
        }
    } else if (writeSuppressedMessagesHint_) {
        std::string suffix;
        if (msg.find(StructuredMessage::name) == string::npos) {
            suffix = " ... suppressing more messages from same source code location (cutoff = " +
                     std::to_string(sameSourceLocationCutoff_) + " lines)";
        }
        for (auto& l : loggers_) {
            l.second->log(m, msg + suffix);
        }
        writeSuppressedMessagesHint_ = false;
    }
}

mutex()

boost::shared_mutex & mutex

(

)

mutex to acquire locks

Definition at line 446 of file log.hpp.

{ return mutex_; }

Here is the caller graph for this function:

filter()

bool filter

(

unsigned

mask

)

Definition at line 449 of file log.hpp.

                               {
        boost::shared_lock<boost::shared_mutex> lock(mutex());
        return 0 != (mask & mask_);
    }

Here is the call graph for this function:

mask()

unsigned mask

(

)

Definition at line 453 of file log.hpp.

                    {
        boost::shared_lock<boost::shared_mutex> lock(mutex());
        return mask_;
    }

Here is the call graph for this function:

Here is the caller graph for this function:

setMask()

void setMask

(

unsigned

mask

)

Definition at line 457 of file log.hpp.

                                {
        boost::unique_lock<boost::shared_mutex> lock(mutex());
        mask_ = mask;
    }

Here is the call graph for this function:

rootPath()

const boost::filesystem::path & rootPath

(

)

Definition at line 461 of file log.hpp.

                                          {
        boost::shared_lock<boost::shared_mutex> lock(mutex());
        return rootPath_;
    }

Here is the call graph for this function:

setRootPath()

void setRootPath

(

const boost::filesystem::path &

pth

)

Definition at line 465 of file log.hpp.

                                                     {
        boost::unique_lock<boost::shared_mutex> lock(mutex());
        rootPath_ = pth;
    }

Here is the call graph for this function:

maxLen()

int maxLen

(

)

Definition at line 469 of file log.hpp.

                 {
        boost::shared_lock<boost::shared_mutex> lock(mutex());
        return maxLen_;
    }

Here is the call graph for this function:

setMaxLen()

void setMaxLen

(

const int

n

)

Definition at line 473 of file log.hpp.

                                {
        boost::unique_lock<boost::shared_mutex> lock(mutex());
        maxLen_ = n;
    }

Here is the call graph for this function:

enabled()

bool enabled

(

)

Definition at line 478 of file log.hpp.

                   {
        boost::shared_lock<boost::shared_mutex> lock(mutex());
        return enabled_;
    }

Here is the call graph for this function:

switchOn()

void switchOn

(

)

Definition at line 482 of file log.hpp.

                    {
        boost::unique_lock<boost::shared_mutex> lock(mutex());
        enabled_ = true;
    }

Here is the call graph for this function:

switchOff()

void switchOff

(

)

Definition at line 486 of file log.hpp.

                     {
        boost::unique_lock<boost::shared_mutex> lock(mutex());
        enabled_ = false;
    }

Here is the call graph for this function:

writeSuppressedMessagesHint()

bool writeSuppressedMessagesHint

(

)

Definition at line 491 of file log.hpp.

                                       {
        boost::shared_lock<boost::shared_mutex> lock(mutex());
        return writeSuppressedMessagesHint_;
    }

Here is the call graph for this function:

setPid()

void setPid

(

const int

pid

)

if a PID is set for the logger, messages are tagged with [1234] if pid = 1234

Definition at line 497 of file log.hpp.

{ pid_ = pid; }

source()

string source ( const char *  filename, int  lineNo  ) const

private

Definition at line 348 of file log.cpp.

                                                         {
    string filepath;
    if (rootPath_.empty()) {
        filepath = filename;
    } else {
        filepath = relative(path(filename), rootPath_).string();
    }
    int lineNoLen = (int)log10((double)lineNo) + 1;      // Length of the int as a string
    int len = 2 + filepath.length() + 1 + lineNoLen + 1; // " (" + file + ':' + line + ')'
 
    if (maxLen_ == 0) {
        return "(" + filepath + ':' + to_string(lineNo) + ')';
    } else {
        if (len <= maxLen_) {
            // pad out spaces
            return string(maxLen_ - len, ' ') + "(" + filepath + ':' + to_string(lineNo) + ')';
        } else {
            // need to trim the filename to fit into maxLen chars
            // need to remove (len - maxLen_) chars + 3 for the "..."
            return "(..." + filepath.substr(3 + len - maxLen_) + ':' + to_string(lineNo) + ')';
        }
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

Friends And Related Function Documentation

QuantLib::Singleton< Log, std::integral_constant< bool, true > >

friend class QuantLib::Singleton< Log, std::integral_constant< bool, true > >

friend

Definition at line 352 of file log.hpp.

Member Data Documentation

loggers_

std::map<std::string, QuantLib::ext::shared_ptr<Logger> > loggers_

private

Definition at line 505 of file log.hpp.

independentLoggers_

std::map<std::string, QuantLib::ext::shared_ptr<IndependentLogger> > independentLoggers_

private

Definition at line 506 of file log.hpp.

enabled_

bool enabled_

private

Definition at line 507 of file log.hpp.

mask_

unsigned mask_

private

Definition at line 508 of file log.hpp.

rootPath_

boost::filesystem::path rootPath_

private

Definition at line 509 of file log.hpp.

ls_

std::ostringstream ls_

private

Definition at line 510 of file log.hpp.

maxLen_

int maxLen_ = 45

private

Definition at line 512 of file log.hpp.

sameSourceLocationSince_

std::size_t sameSourceLocationSince_ = 0

private

Definition at line 513 of file log.hpp.

writeSuppressedMessagesHint_

bool writeSuppressedMessagesHint_ = true

private

Definition at line 514 of file log.hpp.

sameSourceLocationCutoff_

std::size_t sameSourceLocationCutoff_ = 1000

private

Definition at line 515 of file log.hpp.

lastFileName_

std::string lastFileName_

private

Definition at line 516 of file log.hpp.

lastLineNo_

int lastLineNo_ = 0

private

Definition at line 517 of file log.hpp.

pid_

int pid_ = 0

private

Definition at line 519 of file log.hpp.

mutex_

boost::shared_mutex mutex_

mutableprivate

Definition at line 521 of file log.hpp.

excludeFilters_

std::map<std::string, std::function<bool(const std::string&)> > excludeFilters_

private

Definition at line 523 of file log.hpp.