#include <ULogger.h>
Public Types | |
enum | Level { kDebug, kInfo, kWarning, kError, kFatal } |
enum | Type { kTypeNoLog, kTypeConsole, kTypeFile } |
Static Public Member Functions | |
static ULogger::Level | eventLevel () |
static ULogger::Level | exitLevel () |
static void | flush () |
static int | getTime (std::string &timeStr) |
static bool | isBuffered () |
static bool | isPrintColored () |
static bool | isPrintEndLine () |
static bool | isPrintLevel () |
static bool | isPrintTime () |
static bool | isPrintWhere () |
static bool | isPrintWhereFullPath () |
static ULogger::Level | level () |
static void | reset () |
static void | setBuffered (bool buffered) |
static void | setEventLevel (ULogger::Level eventSentLevel) |
static void | setExitLevel (ULogger::Level exitLevel) |
static void | setLevel (ULogger::Level level) |
static void | setPrintColored (bool printColored) |
static void | setPrintEndline (bool printEndline) |
static void | setPrintLevel (bool printLevel) |
static void | setPrintTime (bool printTime) |
static void | setPrintWhere (bool printWhere) |
static void | setPrintWhereFullPath (bool printWhereFullPath) |
static void | setType (Type type, const std::string &fileName=kDefaultLogFileName, bool append=true) |
static Type | type () |
static void | write (const char *msg,...) |
static void | write (ULogger::Level level, const char *file, int line, const char *function, const char *msg,...) |
Static Public Attributes | |
static const std::string | kDefaultLogFileName = "./ULog.txt" |
Protected Member Functions | |
void | _flush () |
ULogger () | |
virtual | ~ULogger () |
Static Protected Member Functions | |
static ULogger * | getInstance () |
Static Protected Attributes | |
static bool | append_ = true |
static std::string | logFileName_ |
Private Member Functions | |
virtual void | _write (const char *msg, va_list arg) |
virtual void | _writeStr (const char *msg) |
Static Private Member Functions | |
static ULogger * | createInstance () |
Static Private Attributes | |
static bool | buffered_ = false |
static std::string | bufferedMsgs_ |
static UDestroyer< ULogger > | destroyer_ |
static Level | eventLevel_ = kFatal |
static bool | exitingState_ = false |
static Level | exitLevel_ = kFatal |
static ULogger * | instance_ = 0 |
static Level | level_ = kWarning |
static const char * | levelName_ [5] = {"DEBUG", " INFO", " WARN", "ERROR", "FATAL"} |
static bool | limitWhereLength_ = false |
static UMutex | loggerMutex_ |
static bool | printColored_ = true |
static bool | printEndline_ = true |
static bool | printLevel_ = true |
static bool | printTime_ = true |
static bool | printWhere_ = true |
static bool | printWhereFullPath_ = false |
static Type | type_ = ULogger::kTypeConsole |
Friends | |
class | UDestroyer< ULogger > |
This class is used to log messages with time on a console, in a file and/or with an event. At the start of the application, call ULogger::setType() with the type of the logger you want (see ULogger::Type, the type of the output can be changed at the run-time.). To use it, simply call the convenient macros UDEBUG(), UINFO(), UWARN(), UERROR(), UFATAL() depending of the severity of the message. You can disable some messages by setting the logger level ULogger::setLevel() to severity you want, defined by ULogger::Level. A fatal message will make the application to exit, printing the message on console (whatever the logger type) and posting a ULogEvent (synchronously... see UEventsManager::post()) before exiting.
The display of the logged messages can be modified:
When using a file logger (kTypeLogger), it can be useful in some application to buffer messages before writing them to hard drive (avoiding hard drive latencies). You can set ULogger::setBuffered() to true to do that. When the buffered messages will be written to file on appllciation exit (ULogger destructor) or when ULogger::flush() is called.
If you want the application to exit on a lower severity level than kFatal, you can set ULogger::setExitLevel() to any ULogger::Type you want.
Example:
#include <utilite/ULogger.h> int main(int argc, char * argv[]) { // Set the logger type. The choices are kTypeConsole, // kTypeFile or kTypeNoLog (nothing is logged). ULogger::setType(ULogger::kTypeConsole); // Set the logger severity level (kDebug, kInfo, kWarning, kError, kFatal). // All log entries under the severity level are not logged. Here, // only debug messages are not logged. ULogger::setLevel(ULogger::kInfo); // Use a predefined Macro to easy logging. It can be // called anywhere in the application as the logger is // a Singleton. UDEBUG("This message won't be logged because the " "severity level of the logger is set to kInfo."); UINFO("This message is logged."); UWARN("A warning message..."); UERROR("An error message with code %d.", 42); return 0; }
Output:
[ INFO] (2010-09-25 18:08:20) main.cpp:18::main() This message is logged. [ WARN] (2010-09-25 18:08:20) main.cpp:20::main() A warning message... [ERROR] (2010-09-25 18:08:20) main.cpp:22::main() An error message with code 42.
Another useful form of the ULogger is to use it with the UTimer class. Here an example:
#include <utilite/ULogger.h> #include <utilite/UTimer.h> ... UTimer timer; // automatically starts // do some works for part A UINFO("Time for part A = %f s", timer.ticks()); // do some works for part B UINFO("Time for part B = %f s", timer.ticks()); // do some works for part C UINFO("Time for part C = %f s", timer.ticks()); ...
enum ULogger::Level |
enum ULogger::Type |
Loggers available:
ULogger::ULogger | ( | ) | [inline, protected] |
ULogger::~ULogger | ( | ) | [protected, virtual] |
Definition at line 587 of file ULogger.cpp.
void ULogger::_flush | ( | ) | [protected] |
Definition at line 241 of file ULogger.cpp.
virtual void ULogger::_write | ( | const char * | msg, |
va_list | arg | ||
) | [inline, private, virtual] |
Reimplemented in UFileLogger, and UConsoleLogger.
virtual void ULogger::_writeStr | ( | const char * | msg | ) | [inline, private, virtual] |
Reimplemented in UFileLogger, and UConsoleLogger.
ULogger * ULogger::createInstance | ( | ) | [static, private] |
Definition at line 572 of file ULogger.cpp.
static ULogger::Level ULogger::eventLevel | ( | ) | [inline, static] |
static ULogger::Level ULogger::exitLevel | ( | ) | [inline, static] |
void ULogger::flush | ( | ) | [static] |
ULogger * ULogger::getInstance | ( | ) | [static, protected] |
Definition at line 563 of file ULogger.cpp.
int ULogger::getTime | ( | std::string & | timeStr | ) | [static] |
Get the time in the format "2008-7-13 12:23:44".
timeStr | string were the time will be copied. |
Definition at line 512 of file ULogger.cpp.
static bool ULogger::isBuffered | ( | ) | [inline, static] |
static bool ULogger::isPrintColored | ( | ) | [inline, static] |
static bool ULogger::isPrintEndLine | ( | ) | [inline, static] |
static bool ULogger::isPrintLevel | ( | ) | [inline, static] |
static bool ULogger::isPrintTime | ( | ) | [inline, static] |
static bool ULogger::isPrintWhere | ( | ) | [inline, static] |
static bool ULogger::isPrintWhereFullPath | ( | ) | [inline, static] |
static ULogger::Level ULogger::level | ( | ) | [inline, static] |
void ULogger::reset | ( | ) | [static] |
Reset to default parameters.
Definition at line 203 of file ULogger.cpp.
void ULogger::setBuffered | ( | bool | buffered | ) | [static] |
Set is the logger buffers messages, default false. When true, the messages are buffered until the application is closed or ULogger::flush() is called.
buffered | true to buffer messages, otherwise set to false. |
Definition at line 218 of file ULogger.cpp.
static void ULogger::setEventLevel | ( | ULogger::Level | eventSentLevel | ) | [inline, static] |
An ULogEvent is sent on each message logged at the specified level. Note : On message with level >= exitLevel, the event is sent synchronously (see UEventsManager::post()).
static void ULogger::setExitLevel | ( | ULogger::Level | exitLevel | ) | [inline, static] |
Make application to exit when a log with level is written (useful for debugging). The message is printed to console (whatever the logger type) and an ULogEvent is sent (synchronously... see UEventsManager::post()) before exiting.
Note : A kFatal level will always exit whatever the level specified here.
static void ULogger::setLevel | ( | ULogger::Level | level | ) | [inline, static] |
static void ULogger::setPrintColored | ( | bool | printColored | ) | [inline, static] |
static void ULogger::setPrintEndline | ( | bool | printEndline | ) | [inline, static] |
static void ULogger::setPrintLevel | ( | bool | printLevel | ) | [inline, static] |
static void ULogger::setPrintTime | ( | bool | printTime | ) | [inline, static] |
static void ULogger::setPrintWhere | ( | bool | printWhere | ) | [inline, static] |
static void ULogger::setPrintWhereFullPath | ( | bool | printWhereFullPath | ) | [inline, static] |
Print the full path: default true. ULogger::setPrintWhere() must be true to have path printed.
printWhereFullPath | true to print the full path, otherwise set to false. |
void ULogger::setType | ( | Type | type, |
const std::string & | fileName = kDefaultLogFileName , |
||
bool | append = true |
||
) | [static] |
Set the type of the logger. When using kTypeFile, the parameter "fileName" would be changed (default is "./ULog.txt"), and optionally "append" if we want the logger to append messages to file or to overwrite the file.
type | the ULogger::Type of the logger. |
fileName | file name used with a file logger type. |
append | if true, the file isn't overwritten, otherwise it is. |
TODO : Can it be useful to have 2 or more types at the same time ? Print in console and file at the same time.
Definition at line 175 of file ULogger.cpp.
static Type ULogger::type | ( | ) | [inline, static] |
void ULogger::write | ( | const char * | msg, |
... | |||
) | [static] |
Write a message directly to logger without level handling.
msg | the message to write. |
... | the variable arguments |
Definition at line 247 of file ULogger.cpp.
void ULogger::write | ( | ULogger::Level | level, |
const char * | file, | ||
int | line, | ||
const char * | function, | ||
const char * | msg, | ||
... | |||
) | [static] |
Definition at line 307 of file ULogger.cpp.
friend class UDestroyer< ULogger > [friend] |
bool ULogger::append_ = true [static, protected] |
bool ULogger::buffered_ = false [static, private] |
std::string ULogger::bufferedMsgs_ [static, private] |
Reimplemented in UFileLogger.
UDestroyer< ULogger > ULogger::destroyer_ [static, private] |
ULogger::Level ULogger::eventLevel_ = kFatal [static, private] |
bool ULogger::exitingState_ = false [static, private] |
ULogger::Level ULogger::exitLevel_ = kFatal [static, private] |
ULogger * ULogger::instance_ = 0 [static, private] |
const std::string ULogger::kDefaultLogFileName = "./ULog.txt" [static] |
ULogger::Level ULogger::level_ = kWarning [static, private] |
const char * ULogger::levelName_ = {"DEBUG", " INFO", " WARN", "ERROR", "FATAL"} [static, private] |
bool ULogger::limitWhereLength_ = false [static, private] |
std::string ULogger::logFileName_ [static, protected] |
UMutex ULogger::loggerMutex_ [static, private] |
bool ULogger::printColored_ = true [static, private] |
bool ULogger::printEndline_ = true [static, private] |
bool ULogger::printLevel_ = true [static, private] |
bool ULogger::printTime_ = true [static, private] |
bool ULogger::printWhere_ = true [static, private] |
bool ULogger::printWhereFullPath_ = false [static, private] |
ULogger::Type ULogger::type_ = ULogger::kTypeConsole [static, private] |