Simple Logger for C++

• Download source files - 656.2 KB

Overview 

Recently, I have been on the lookout for a relatively easy to use logging feature for my C++ applications. There are a lot of good frameworks out there. I wasn't so much as looking for using or even copy pasting available code than I was looking for approaches to logging. Then I went through Log 4 C++. It's a nice framework. This logging class which I present here is based on ideas from Log 4 C++ in that the usage pattern is similar to Log 4 C++. Most logging frameworks provide a plethora of tweaks and formatting options which this little class here does not, and this is precisely why I find using it very easy. The entire code fits into one single .h file and is easily understandable and can therefore be easily modified to suit one's needs. Please note, the code uses some of the C++ 11 features. However, it should be relatively easy to get the code to work with the older specification; for example, replace 'enum class' with just 'enum'. Visit http://en.wikipedia.org/wiki/C%2B%2B11 for more information. The sample code compiled in Visual Studio 2012.

Design   

The main class which we need to be concerned about is the CLogger class. It is present in the 'framework:: Diagnostics' namespace. CLogger takes the help of another class for thread-synchronization functions. As of now, there are two classes which help with this and both are present under the framework::Threading namespace. One of them is called CIntraProcessLock. Use this if you are sharing an instance of CLogger across multiple threads in the same process. If you are not sharing a logger object across threads, use the CNoLock class. When creating an instance of the logger, you need to supply at least one of these or any other class which provides semantically correct Lock() and Unlock() functionality. Once the CLogger instance is created, we need to add ostream derived objects which perform the actual task of writing something somewhere. Finally to log something, use the WRITELOG macro.

Usage 

Creating the logger. Example:

using namespace framework::Diagnostics;
using namespace framework::Threading;
CLogger<CNolock> logger(LogLevel::Info, _T("MyApp"));

The constructor has the following parameters:

• LogLevel - can be one of the enum values of framework::Diagnostics::LogLevel enumeration. This value affects what gets logged. This value is used when you add an output stream.
• Name - A name given to a logger object. This name can appear in each log line. I usually have one logger object for a module and give the name of the module here.  
• logItems - This is a bitmask of the list of items we want to output to each log line. The values should be taken from the framework::Diagnostics::LogItem enumeration. By default, the following items are logged:

Suppose you want to log only the date-time and the actual log statement, you would create a logger object like:

CLogger<CNoLock> logger(LogLevel::Info, _T("MyApp"), static_cast<int>(LogItem::DateTime));

Note, there is no way to prevent actual log statements from being written so there is no LogItem for it.

The next step is to add the output streams. For each output stream that you add, you can specify the logging-level. For example, we can add 'cout' and specify a logging-level of Error. This would mean that the level-specified and all levels higher than this will be logged.

Similarly, if one adds a file stream and specifies Info as the log-level, all levels above Info and Info itself will be logged, which in effect means log everything since all other levels are higher than Info (see the enum LogLevel). Example:

logger.AddOutputStream(std::wcout, false, LogLevel::Error);
logger.AddOutputStream(new std::wofstream("c:\\temp\\myapp.log"), 
       true, framework::Diagnostics::LogLevel::Info);

The addOutputStream has the following parameters:

• os - pass any ostream derived class, e.g., cout or wcout.
• own - if true, the CLogger instance will use the delete operator to delete the passed in ostream object. This is usually useful if you are creating a new instance of a filestream and passing it in (see the code above).
• LogLevel - all log entries equal to or higher will be written for this device (output stream). If nothing is specified, the logging level specified on the CLogger object will be used to decide what gets logged. Finally, to perform the logging itself, it is recommended that one use the WRITELOG, LOGINFO, LOGDEBUG, LOGWARN or LOGERROR macro. Example:

WRITELOG(logger, framework::Diagnostics::LogLevel::Info, _T("Program starting"));
WRITELOG(logger, framework::Diagnostics::LogLevel::Warn, _T("Something may have gone wrong"));
WRITELOG(logger, framework::Diagnostics::LogLevel::Error, _T("Something did go wrong"));
WRITELOG(logger, framework::Diagnostics::LogLevel::Info, _T("Program Ending"));

// Or use shortcut macros like LOGINFO, LOGDEBUG, LOGWARN, LOGERROR. E.g.
LOGINFO(logger, _T("Program Ending"));

// If you have a pointer to a logger object e.g:
CLogger<cnolock>* loggerPtr = &logger; 
LOGINFOP(loggerPtr, _T("Program Ending"));

</cnolock>

In case you have a pointer to a logger object, you can use the same macros suffixed with 'P' (P for pointer) which are WRITELOGP, LOGINFOP, LOGDEBUGP, LOGWARNP or LOGERRORP

The entire code is in one place:

#include "threading.h"
#include "Logger.h"
#include <fstream>

using namespace framework::Diagnostics;
using namespace framework::Threading;

int _tmain(int argc, _TCHAR* argv[])
{
    CLogger<CNolock> logger(LogLevel::Info, _T("MyApp"));

    logger.AddOutputStream(std::wcout, false, LogLevel::Error);
    logger.AddOutputStream(new std::wofstream("c:\\temp\\myapp.log"), 
           true, framework::Diagnostics::LogLevel::Info);
        
    WRITELOG(logger, framework::Diagnostics::LogLevel::Info, _T("Program starting"));
    WRITELOG(logger, framework::Diagnostics::LogLevel::Warn, _T
            ("Something may have gone wrong"));
    WRITELOG(logger, framework::Diagnostics::LogLevel::Error, _T("Something did go wrong"));
    CLogger<CNoLock>* loggerPtr = &logger; // An easy way to use pointer to a logger object
	LOGINFOP(loggerPtr, _T("Program Ending"));
    return 0;
}

Thanks   

The use of templated classes for performing thread synchronization is based on the concept of policy-classes (refer to 'Modern C++ Design' by 'Andrei Alexander). Log 4 C++ inspired the overall design of this class.

Thanks to my wife Meena for always being there and my son Neel for showing how simple it is to have a happy life.

History

• 6^th June, 2015: Initial version