TradingServerEngine/Logging.hpp at master · rrsathe/TradingServerEngine · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
#pragma once

#include <atomic>
#include <condition_variable>
#include <fstream>
#include <mutex>
#include <queue>
#include <sstream>
#include <string>
#include <thread>

enum class LogLevel {
	Debug,
	Information,
	Warning,
	Error,
	Critical
};

inline const char *LogLevelToString(LogLevel level) {
	switch (level) {
	case LogLevel::Debug:
		return "Debug";
	case LogLevel::Information:
		return "Information";
	case LogLevel::Warning:
		return "Warning";
	case LogLevel::Error:
		return "Error";
	case LogLevel::Critical:
		return "Critical";
	default:
		return "Unknown";
	}
}

class ILogger {
  public:
	virtual ~ILogger() = default;
	virtual void Debug(const std::string &module, const std::string &message) = 0;
	virtual void Information(const std::string &module, const std::string &message) = 0;
	virtual void Warning(const std::string &module, const std::string &message) = 0;
	virtual void Error(const std::string &module, const std::string &message) = 0;
};

class AbstractLogger : public ILogger {
  protected:
	virtual void Log(LogLevel level, const std::string &module, const std::string &message) = 0;

  public:
	void Debug(const std::string &module, const std::string &message) override {
		Log(LogLevel::Debug, module, message);
	}
	void Information(const std::string &module, const std::string &message) override {
		Log(LogLevel::Information, module, message);
	}
	void Warning(const std::string &module, const std::string &message) override {
		Log(LogLevel::Warning, module, message);
	}
	void Error(const std::string &module, const std::string &message) override {
		Log(LogLevel::Error, module, message);
	}
};

class TextLogger : public AbstractLogger {
	std::ofstream logFile;
	std::queue<std::string> logQueue;
	std::mutex queueMutex;
	std::condition_variable cv;
	std::atomic<bool> running;
	std::thread worker;

	void ProcessQueue() {
		while (running || !logQueue.empty()) {
			std::unique_lock<std::mutex> lock(queueMutex);
			cv.wait(lock, [this] { return !logQueue.empty() || !running; });
			while (!logQueue.empty()) {
				logFile << logQueue.front() << std::endl;
				logQueue.pop();
			}
		}
	}

  protected:
	void Log(LogLevel level, const std::string &module, const std::string &message) override {
		std::ostringstream oss;
		oss << "[" << ToString(level) << "] " << module << ": " << message;
		{
			std::lock_guard<std::mutex> lock(queueMutex);
			logQueue.push(oss.str());
		}
		cv.notify_one();
	}

  public:
	TextLogger(const std::string &filePath)
		: logFile(filePath), running(true), worker(&TextLogger::ProcessQueue, this) {}

	~TextLogger() {
		running = false;
		cv.notify_all();
		if (worker.joinable())
			worker.join();
		logFile.close();
	}

	static std::string ToString(LogLevel level) {
		switch (level) {
		case LogLevel::Debug:
			return "DEBUG";
		case LogLevel::Information:
			return "INFO";
		case LogLevel::Warning:
			return "WARN";
		case LogLevel::Error:
			return "ERROR";
		default:
			return "UNKNOWN";
		}
	}
};