/*
 * Logger.h
 *
 *  Created on: Jan 4, 2009
 *      Author: Karl
 */
#include <iostream>
#include <fstream>
#include <string>
#include <time.h>

#ifndef LOGGER_H_
#define LOGGER_H_

class Logger {
public:
	static Logger* Instance();
	~Logger();

	//Logging Levels
	const static int LOG_LEVEL_NO_LOGGING = 0;
	const static int LOG_LEVEL_FATAL = 1;
	const static int LOG_LEVEL_SEVERE = 2;
	const static int LOG_LEVEL_WARNING = 3;
	const static int LOG_LEVEL_INFO = 4;
	const static int LOG_LEVEL_CONFIG = 5;
	const static int LOG_LEVEL_VERBOSE = 6;
	const static int LOG_LEVEL_VERY_VERBOSE = 7;

	//Logging Targets
	const static int LOG_TARGET_FILE = 1;
	const static int LOG_TARGET_STDOUT = 2;
	const static int LOG_TARGET_BOTH = 3;

	void SetLoggingLevel(int);

	void SetLoggingTarget(int);

	void Log(int, std::string);

protected:
	Logger();
	Logger(const Logger&);
	Logger& operator= (const Logger&);

private:
	std::ofstream file;
	static Logger* pinstance;
};

#endif /* LOGGER_H_ */

/*
 * Logger.cpp
 *
 *  Created on: Jan 4, 2009
 *      Author: Karl
 */

#include "Logger.h"

Logger* Logger::pinstance = 0;
int loggingLevel = 4;
int loggingTarget = 1;

Logger* Logger::Instance()
{
	if (pinstance == 0)
	{
		pinstance = new Logger;
	}
	return pinstance;
}

Logger::Logger()
{
	file.open ("logger.log");
	Log(LOG_LEVEL_INFO, "Log Opened");
}

Logger::~Logger()
{
	file.close();
}

void Logger::SetLoggingLevel(int logLevel)
{
	if ((logLevel >= LOG_LEVEL_NO_LOGGING) && (logLevel <= LOG_LEVEL_VERY_VERBOSE))
	{
		loggingLevel = logLevel;
	}
}

void Logger::SetLoggingTarget(int logTarget){
	if ((logTarget >= LOG_TARGET_FILE) && (logTarget <= LOG_TARGET_BOTH))
	{
		loggingTarget = logTarget;
	}
}

void Logger::Log(int logLevel, std::string logMsg)
{
	if (logLevel <= loggingLevel)
	{
		std::string msgToWrite;
		time_t rawtime;
		struct tm * timeinfo;

		time ( &rawtime );
		timeinfo = localtime ( &rawtime );
		msgToWrite += asctime(timeinfo);
		msgToWrite.erase(msgToWrite.end()-1,msgToWrite.end());
		msgToWrite += " - ";

		switch (logLevel) {

		case LOG_LEVEL_FATAL:
			msgToWrite += "FATAL - ";
			break;
		case LOG_LEVEL_SEVERE:
			msgToWrite += "SEVERE - ";
			break;
		case LOG_LEVEL_WARNING:
			msgToWrite += "WARNING - ";
			break;
		case LOG_LEVEL_INFO:
			msgToWrite += "INFO - ";
			break;
		case LOG_LEVEL_CONFIG:
			msgToWrite += "CONFIG - ";
			break;
		case LOG_LEVEL_VERBOSE:
			msgToWrite += "VERBOSE - ";
			break;
		case LOG_LEVEL_VERY_VERBOSE:
			msgToWrite += "VERY VERBOSE - ";
			break;
		default:
			msgToWrite += "UNKNOWN LEVEL - ";
			break;
		}

		msgToWrite += logMsg;
		msgToWrite += "\n";

		switch(loggingTarget){
		case LOG_TARGET_FILE:
			file << msgToWrite;
			break;
		case LOG_TARGET_STDOUT:
			std::cout << msgToWrite;
			break;
		case LOG_TARGET_BOTH:
			msgToWrite += "\n";
			file << msgToWrite;
			std::cout << msgToWrite;
			break;
		}
	file.flush();
	}

}

Example Usage:

Logger *logger = Logger::Instance();

.

.

.

logger->Log(logger->LOG_LEVEL_INFO, “Starting the Plugin”);