Log/Log.cpp

#include "Log.h"

#include <chrono>   // date/time
#include <fstream>  // ofstream (logging to file)
#include <iostream> // std::ostream, std::cout, std::cin
#include <memory>   // std::unique_ptr

#if LOG_USEMUTEX == 1
#include <mutex>
#endif

namespace Log {

/*
 * abstract class Output
 *   default implementations
 */

// abstract base class for a log sink
class Output {
public:
	Output() = default;
	explicit Output(Level lvl_max) : lvl_max{lvl_max} {}
	virtual ~Output() = default;

	virtual void log(Level lvl, std::stringbuf* sbuf) {
		//aquire lock
		#if LOG_USEMUTEX == 1
		std::unique_lock<std::mutex> lock(ostreamLock);
		#endif

		std::ostream* os = getOs(lvl);
		if (os) {
			*os << sbuf;
			os->put('\n');
		}
	};

	virtual void setLogLevel(Level lvl) { lvl_max = lvl; }

protected:
	Level lvl_max = Level::info;
	// returns the correct ostream for the given log-level
	// or returns nullptr if no ostream is set/enabled for this level
	virtual std::ostream* getOs(Level lvl) = 0; // abstract

	#if LOG_USEMUTEX == 1
	std::mutex ostreamLock; //used for both streams
	#endif
};

// logging to stdout/stderr
class ConsoleOutput : public Output {
public:
	ConsoleOutput() = default;

	virtual bool setColoredOutput(bool enabled) {
		// TODO: check the terminal's compatibility for colors
		coloredOutput = enabled;
		return true;
	}

private:
	std::ostream* osStd = &std::cout;
	std::ostream* osErr = &std::cerr;
	bool coloredOutput = false;

	virtual void log(Level lvl, std::stringbuf* sbuf) {
		//                                  off    fatal    error  warn   note   info   debug trace
		static const char* color_codes[] = {"", "1;31;40m", "31m", "33m", "96m", "32m", "0m", "0m"};

		//aquire lock
		#if LOG_USEMUTEX == 1
		std::unique_lock<std::mutex> lock(ostreamLock);
		#endif

		std::ostream* os = getOs(lvl);

		if (os) {
			// print colors if enabled
			if (coloredOutput) {
				*os << "\x1B[" << color_codes[static_cast<int>(lvl)] << sbuf << "\x1B[0m";
			} else {
				*os << sbuf;
			}

			os->put('\n');
		}
	}

	virtual std::ostream* getOs(Level lvl) {
		// out of scope?
		if (lvl == Level::off || lvl > lvl_max) {
			return nullptr;
		}

		// stderr for fatal, error, warn
		if (lvl <= Level::warn) {
			return osErr;
		} else {
			return osStd;
		}
	}
};

class FileOutput : public Output {
public:
	FileOutput(const std::string& filename, Level lvl_max, bool truncate)
	    : Output(lvl_max), filename(filename), ofs(filename, truncate ? std::ostream::trunc : std::ostream::app) {}

	FileOutput(const std::string& filename, Level lvl_min, Level lvl_max, bool truncate)
	    : Output(lvl_max),
	      filename(filename),
	      ofs(filename, truncate ? std::ostream::trunc : std::ostream::app),
	      lvl_min(lvl_min) {}

private:
	std::string filename;
	std::ofstream ofs;
	Level lvl_min = Level::fatal;

	#if LOG_USEMUTEX == 1
	std::mutex ostreamLock; //used for both streams
	#endif

	virtual std::ostream* getOs(Level lvl) {
		if (lvl_min <= lvl && lvl <= lvl_max) {
			return &ofs;
		}
		return nullptr;
	}
};

static std::vector<std::unique_ptr<Output>> outputs;

void log(Level lvl, std::stringbuf* strb) {
	for (auto&& out : outputs) {
		out->log(lvl, strb);
		// reset stringbuffer read pointer to the beginning
		strb->pubseekpos(0);
	}
}

const LeveledSink fatal{Level::fatal};
const LeveledSink error{Level::error};
const LeveledSink warn{Level::warn};
const LeveledSink note{Level::note};
const LeveledSink info{Level::info};
const LeveledSink debug{Level::debug};
const LeveledSink trace{Level::trace};

/*
 * class Entry
 */

Entry::Entry(Level lvl) : lvl{lvl} {
	for(auto metafunc : entryMetaFunctions) {
		metafunc(ss, *this);
	}
}

Entry::~Entry() {
	log(lvl, ss.rdbuf());
}

std::vector<Entry::MetaFunction> entryMetaFunctions;

std::ostream& defaultEntryMetaTime(std::ostream& os, const Entry& e) {
	(void) e; // unused

	using namespace std::chrono;
	auto now = system_clock::to_time_t(system_clock::now());
	auto tm = *std::localtime(&now);

	// MinGW doesn't support the ISO8601 formatting characters like "%F" and "%T"
	// ref: https://sourceforge.net/p/mingw-w64/bugs/793/
	// Therefore, use a more verbose time string
	char buf[24];
	std::strftime(buf, sizeof(buf), "[%Y-%m-%d %H:%M:%S]", &tm);
	return os << buf;
}

std::ostream& defaultEntryMetaLevel(std::ostream& os, const Entry& e) {
	static const char* LevelTag[] = {
		"", "[FATAL]", "[ERROR]", "[WARN ]", "[NOTE ]", "[INFO ]", "[DEBUG]", "[TRACE]"
	};
	return os << LevelTag[static_cast<int>(e.getLevel())];
}

void init() {
	// add default console logger
	if (outputs.empty()) {
		outputs.push_back(std::unique_ptr<Output>(new ConsoleOutput()));
	}

	// set default entry metadata printing functions
	auto space = [](std::ostream& os, const Entry& e) -> std::ostream& {
		(void) e;
		return os.put(' ');
	};
	entryMetaFunctions = {
		defaultEntryMetaTime,
		defaultEntryMetaLevel,
		space
	};
}

void stop() {
	outputs.clear();
}

void addLogfile(const std::string& filename, Level max, bool truncate) {
	outputs.push_back(std::unique_ptr<Output>(new FileOutput(filename, max, truncate)));
}

void addLogfile(const std::string& filename, Level min, Level max, bool truncate) {
	outputs.push_back(std::unique_ptr<Output>(new FileOutput(filename, min, max, truncate)));
}

void setConsoleLogLevel(Level lvl) {
	outputs.at(0)->setLogLevel(lvl); // has to exist
}

void setColoredOutput(bool enabled) {
	dynamic_cast<ConsoleOutput&>(*outputs.at(0)).setColoredOutput(enabled); // has to exist
}

} // namespace Log