ofLogfile

ofLog provides an interface for writing text output from your app. It's basically a more useful version of std::cout or printf where the output can be filtered and written to the console a file, or even a custom logging module.

Sometimes you want to be able to see when something has happened inside the code, but don't need to draw something visually. Oftentimes it's more then enough to print out the state of a few variables when debugging. Other times you need to know if a crash happened while your app was running somewhere, so you log messages and variables to a file you can read after the program crashes.

Log Levels

You can set the logging level so only messages above a certain level are shown. This is useful if you want see lots of messages when debugging, but then set a higher level so only warnings and errors appear for users.

See ofSetLogLevel(ofLogLevel level) for more details.

Usage

There are 2 ways you can use ofLog:

Functional: as a function taking a message

// Send a single string message, setting the log level.
ofLog(OF_LOG_NOTICE, "the number is " + ofToString(10));
// The legacy printf style.
ofLog(OF_LOG_NOTICE, "the number is %d", 10); 

Stream: as a stream using the << stream operator

// The stream style, setting the log level to OF_LOG_WARNING.
ofLog(OF_LOG_WARNING) << "the number is " << 10;
// This is the same as the last line, except it uses the default OF_LOG_NOTICE.
ofLog() << "the number is " << 10;
// There are also log level-specific stream objects, one for each level
// except OF_LOG_SILENT.
ofLogVerbose() << "A verbose message."
ofLogNotice() << "A regular notice message.";
ofLogWarning() << "Uh oh, a warning!";
ofLogError() << "Oh no, an error occurred!";
ofLogFatalError() << "Accckkk, a fatal error!!";

Note: The log level specific stream objects also take a string argument for the "module". A module is a string that is added to the beginning of the log line and can be used to separate logging messages by setting an independent log level for that module only. This module-specific log level has no effect on other modules.

See ofSetLogLevel(string module, ofLogLevel level) for more details.

Example of logging to a specific module:

// log to a module called "Hello"

ofLogWarning("Hello") << "A warning message.";

Warning: It is important to understand that the log level specific stream objects take the module name as an argument and the log messages via the << operator. Putting your message as a string argument inside the parentheses uses that message as a module and so nothing will be printed:

// This prints a warning message.
ofLogWarning() << "A warning message.";
// !!! This does not print a message because the string "a warning print"
// is the module argument !!!
ofLogWarning("A warning print");
// This prints a warning message to the "Hello" module.
ofLogWarning("Hello") << "A warning message.";

Log Message Redirection

It's useful to be able to record log messages to a file or send them to a custom destination.

For log redirection see

Global logging level

ofLogLevel enum

Enumerator
OF_LOG_VERBOSE
OF_LOG_NOTICE
OF_LOG_WARNING
OF_LOG_ERROR
OF_LOG_FATAL_ERROR
OF_LOG_SILENT	ofSetLogLevel(OF_LOG_SILENT).

ofSetLogLevel ()

ofGetLogLevel ()

ofGetLogLevelName ()

Global logger channel

ofLogToFile ()

ofLogToConsole ()

ofSetLoggerChannel ()

ofLogclass

A C++ stream-style logging interface.

ofLog accepts variables via the std::ostream operator << and builds a string and logs it when the stream is finished (via the destructor). A newline is printed automatically and all the stream controls (std::endl, std::flush, std::hex, etc) work normally. The default log level is OF_LOG_NOTICE.

Basic usage:

ofLog() << "My integer is " << 100 << " and my float is " << 20.234f;

It also accepts the legacy ofLog interface: ofLog(ofLogLevel level, string message):

ofLog(OF_LOG_ERROR, "Another string.");

Author: Dan Wilcox danom.nosp@m.atik.nosp@m.a@gma.nosp@m.il.c.nosp@m.om danomatika.com

Logging

ofLog ()

ofLog()

Start logging on notice level.

ofLog provides a streaming log interface by accepting variables via the std::ostream operator << similar to std::cout and std::cerr.

It builds a string and logs it when the stream is finished. A newline is printed automatically and all the stream controls (std::endl, std::flush, std::hex, etc) work normally.

// Converts primitive types (int, float, etc) to strings automatically.

ofLog() << "a string " << 100 << 20.234f;

The log level is OF_LOG_NOTICE by default.

ofLog(ofLogLevel level)

Start logging on a specific ofLogLevel.

Example:

// Set the log level.

ofLog(OF_LOG_WARNING) << "a string " << 100 << 20.234f;

You can use the derived convenience classes as an alternative for specific log levels:

ofLogVerbose()
ofLogNotice()
ofLogWarning()
ofLogError()
ofLogFatalError()

// Set the log level.
ofLog(OF_LOG_WARNING) << "a string " << 100 << 20.234f;
// This is the same as above.
ofLogWarning() << "a string " << 100 << 20.234f;

Parameters

level The ofLogLevel for this log message.

ofLog(ofLogLevel level, const string &message)

Log a string at a specific log level.

Supply the logging message as a parameter to the function instead of as a stream.

The string message can be concatenated using the ofToString(const T& value) conversion function:

// Build a single string message.
ofLog(OF_LOG_NOTICE, "the number is " 
+ ofToString(10) + " and I have a float too " + ofToString(123.45f));

Parameters

level	The ofLogLevel for this log message.
message	The log message.

ofLog(ofLogLevel level, const char *format,...) OF_PRINTF_ATTR(3

Logs a message at a specific log level using the printf interface.

The message is built using the formatting from the C printf function and can be used as a direct replacement. Essentially, the second argument is a string with special formatting specifiers starting with '' that specify where the following variables go in the message. You can have as many variables as you want following the logLevel and format string, but there must be a % specifier for each subsequent variable.

For quick reference, here are a few of the most useful formatting specifiers:

d: integer number, 123
f: floating point number, 123.45
s: a C string (null terminated); this is not a C++ string, use string::c_str() to get a C string from a C++ string
c: a single character
x: unsigned integer as a hexidecimal number; x uses lower-case letters and X uses upper-case
%%: prints a % character

The specifier should match the variable type as it is used to tell the function how to convert that primitive type (int, float, character, etc) into a string.

For instance, let's say we want to print two messages, a salutation and the value of an int, a float, and a string variable:

// Print a simple message with no variables.
ofLog(OF_LOG_WARNING, "Welcome to the jungle.");
// Our variables.
float fun = 11.11;
int games = 100;
string theNames = "Dan, Kyle, & Golan";
// Print a message with variables, sets the message format in the
// format string.
ofLog(OF_LOG_NOTICE, "we've got %d & %f, we got everything you want honey, we know %s", fun, games, theNames.c_str());

Note: theNames.c_str() returns a C string from theNames which is a C++ string object.

There are other formatting options such as setting the decimal precision of float objects and the forward padding of numbers (i.e. 0001 instead of 1). See the Wikipedia printf format string article for more detailed information.

Parameters

level	The ofLogLevel for this log message.
format	The printf-style format string.

Logging configuration

Functions

ofLogFatalError ()

path	The path to the log file to use.
append	True if you want to append to the existing file.

level	The ofLogLevel you want as a string.
pad	True if you want all log level names to be the same length.

module	The target module.
format	The printf-style format string.