From e4a0432383331e013808a97b7c24707e4ddc4726 Mon Sep 17 00:00:00 2001 From: srdusr Date: Fri, 26 Sep 2025 12:23:19 +0200 Subject: Initial Commit --- src/utils/logger.cc | 126 ++++++++++++++++++++++++++++++++++++++++++++++++++++ src/utils/logger.h | 92 ++++++++++++++++++++++++++++++++++++++ 2 files changed, 218 insertions(+) create mode 100644 src/utils/logger.cc create mode 100644 src/utils/logger.h (limited to 'src/utils') diff --git a/src/utils/logger.cc b/src/utils/logger.cc new file mode 100644 index 0000000..92d26d9 --- /dev/null +++ b/src/utils/logger.cc @@ -0,0 +1,126 @@ +#include "logger.h" +#include +#include +#include +#include +#include + +// Global logger instance +Logger g_logger; + +Logger::Logger() + : current_level(LogLevel::INFO) + , console_enabled(true) + , file_enabled(false) { +} + +Logger::~Logger() { + if (file_stream) { + file_stream->flush(); + } +} + +void Logger::set_level(LogLevel level) { + current_level = level; +} + +void Logger::debug(const std::string& message) { + log(LogLevel::DEBUG, message); +} + +void Logger::info(const std::string& message) { + log(LogLevel::INFO, message); +} + +void Logger::warning(const std::string& message) { + log(LogLevel::WARNING, message); +} + +void Logger::error(const std::string& message) { + log(LogLevel::ERROR, message); +} + +void Logger::fatal(const std::string& message) { + log(LogLevel::FATAL, message); +} + +void Logger::log(LogLevel level, const std::string& message) { + if (level >= current_level) { + write_log(level, message); + } +} + +void Logger::set_output_file(const std::string& filename) { + output_filename = filename; + if (file_enabled && !filename.empty()) { + file_stream = std::make_unique(filename, std::ios::app); + if (!file_stream->good()) { + std::cerr << "Failed to open log file: " << filename << std::endl; + file_stream.reset(); + } + } +} + +void Logger::enable_console(bool enable) { + console_enabled = enable; +} + +void Logger::enable_file(bool enable) { + file_enabled = enable; + if (enable && !output_filename.empty()) { + set_output_file(output_filename); + } else if (!enable) { + file_stream.reset(); + } +} + +std::string Logger::level_to_string(LogLevel level) { + switch (level) { + case LogLevel::DEBUG: return "DEBUG"; + case LogLevel::INFO: return "INFO"; + case LogLevel::WARNING: return "WARNING"; + case LogLevel::ERROR: return "ERROR"; + case LogLevel::FATAL: return "FATAL"; + default: return "UNKNOWN"; + } +} + +std::string Logger::get_timestamp() { + auto now = std::chrono::system_clock::now(); + auto time_t = std::chrono::system_clock::to_time_t(now); + auto ms = std::chrono::duration_cast( + now.time_since_epoch()) % 1000; + + std::stringstream ss; + ss << std::put_time(std::localtime(&time_t), "%Y-%m-%d %H:%M:%S"); + ss << '.' << std::setfill('0') << std::setw(3) << ms.count(); + return ss.str(); +} + +void Logger::write_log(LogLevel level, const std::string& message) { + std::string timestamp = get_timestamp(); + std::string level_str = level_to_string(level); + std::string log_entry = "[" + timestamp + "] [" + level_str + "] " + message + "\n"; + + if (console_enabled) { + if (level == LogLevel::ERROR || level == LogLevel::FATAL) { + std::cerr << log_entry; + } else { + std::cout << log_entry; + } + } + + if (file_enabled && file_stream && file_stream->good()) { + *file_stream << log_entry; + file_stream->flush(); + } +} + +// LogStream implementation +LogStream::LogStream(Logger& logger, LogLevel level) + : logger(logger), level(level) { +} + +LogStream::~LogStream() { + logger.log(level, stream.str()); +} diff --git a/src/utils/logger.h b/src/utils/logger.h new file mode 100644 index 0000000..2896c7e --- /dev/null +++ b/src/utils/logger.h @@ -0,0 +1,92 @@ +#ifndef SRDWM_LOGGER_H +#define SRDWM_LOGGER_H + +#include +#include +#include + +// Log levels +enum class LogLevel { + DEBUG, + INFO, + WARNING, + ERROR, + FATAL +}; + +// Logger class +class Logger { +public: + Logger(); + ~Logger(); + + // Set log level + void set_level(LogLevel level); + + // Logging methods + void debug(const std::string& message); + void info(const std::string& message); + void warning(const std::string& message); + void error(const std::string& message); + void fatal(const std::string& message); + + // Log with level + void log(LogLevel level, const std::string& message); + + // Set output file + void set_output_file(const std::string& filename); + + // Enable/disable console output + void enable_console(bool enable); + + // Enable/disable file output + void enable_file(bool enable); + +private: + LogLevel current_level; + bool console_enabled; + bool file_enabled; + std::string output_filename; + std::unique_ptr file_stream; + + std::string level_to_string(LogLevel level); + std::string get_timestamp(); + void write_log(LogLevel level, const std::string& message); +}; + +// Global logger instance +extern Logger g_logger; + +// Convenience macros +#define LOG_DEBUG(msg) g_logger.debug(msg) +#define LOG_INFO(msg) g_logger.info(msg) +#define LOG_WARNING(msg) g_logger.warning(msg) +#define LOG_ERROR(msg) g_logger.error(msg) +#define LOG_FATAL(msg) g_logger.fatal(msg) + +// Stream-based logging +class LogStream { +public: + LogStream(Logger& logger, LogLevel level); + ~LogStream(); + + template + LogStream& operator<<(const T& value) { + stream << value; + return *this; + } + +private: + Logger& logger; + LogLevel level; + std::ostringstream stream; +}; + +// Stream logging macros +#define LOG_STREAM_DEBUG LogStream(g_logger, LogLevel::DEBUG) +#define LOG_STREAM_INFO LogStream(g_logger, LogLevel::INFO) +#define LOG_STREAM_WARNING LogStream(g_logger, LogLevel::WARNING) +#define LOG_STREAM_ERROR LogStream(g_logger, LogLevel::ERROR) +#define LOG_STREAM_FATAL LogStream(g_logger, LogLevel::FATAL) + +#endif // SRDWM_LOGGER_H -- cgit v1.2.3