LogService.hpp

Go to the documentation of this file.

#pragma once

 
#include <icarus/core/CoreTypes.hpp>
#include <icarus/io/log/Console.hpp>
 
#include <algorithm>
#include <chrono>
#include <functional>
#include <iomanip>
#include <mutex>
#include <sstream>
#include <string>
#include <string_view>
#include <vector>
 
namespace icarus {
 
// =============================================================================
// LogConfig
// =============================================================================

struct LogConfig {
    // Console output
    LogLevel console_level = LogLevel::Info;
    bool progress_enabled = true;
 
    // File output
    bool file_enabled = false;
    std::string file_path;
    LogLevel file_level = LogLevel::Debug;
    bool file_rotate = false;
    std::size_t max_file_size_mb = 100;
 
    // Features
    bool profiling_enabled = false;
    bool quiet_mode = false; 
 
    // Telemetry recording
    bool telemetry_enabled = false;
    std::string telemetry_path;
    std::vector<std::string> telemetry_signals; 

    [[nodiscard]] static LogConfig Default() {
        LogConfig config;
        return config;
    }

    [[nodiscard]] static LogConfig Quiet() {
        LogConfig config;
        config.console_level = LogLevel::Error;
        config.progress_enabled = false;
        config.quiet_mode = true;
        return config;
    }

    [[nodiscard]] static LogConfig Verbose() {
        LogConfig config;
        config.console_level = LogLevel::Trace;
        config.file_enabled = true;
        config.file_level = LogLevel::Trace;
        return config;
    }

    [[nodiscard]] static LogConfig WithProfiling() {
        LogConfig config;
        config.profiling_enabled = true;
        return config;
    }
};
 
// =============================================================================
// LogContext
// =============================================================================

struct LogContext {
    std::string entity;    
    std::string component; 
    std::string type;      

    [[nodiscard]] std::string FullPath() const { return MakeFullPath(entity, component); }

    [[nodiscard]] bool IsSet() const { return !component.empty(); }
};
 
// =============================================================================
// LogEntry
// =============================================================================

struct LogEntry {
    LogLevel level;      
    double sim_time;     
    std::string message; 
    LogContext context;  

    std::chrono::steady_clock::time_point wall_time;

    static LogEntry Create(LogLevel level, double sim_time, std::string_view message,
                           const LogContext &ctx) {
        LogEntry entry;
        entry.level = level;
        entry.sim_time = sim_time;
        entry.message = std::string(message);
        entry.context = ctx;
        entry.wall_time = std::chrono::steady_clock::now();
        return entry;
    }

    [[nodiscard]] std::string Format(bool include_context = true) const {
        std::ostringstream oss;
        oss << "[" << std::fixed << std::setprecision(3) << sim_time << "] ";
        oss << "[" << GetLevelString(level) << "] ";
 
        if (include_context && context.IsSet()) {
            oss << "[" << context.FullPath() << "] ";
        }
 
        oss << message;
        return oss.str();
    }

    [[nodiscard]] std::string FormatColored(const Console &console) const {
        std::ostringstream oss;
 
        // Time in dim
        oss << console.Colorize("[", AnsiColor::Dim);
        oss << std::fixed << std::setprecision(3) << sim_time;
        oss << console.Colorize("]", AnsiColor::Dim) << " ";
 
        // Level with appropriate color
        oss << console.Colorize("[" + std::string(GetLevelString(level)) + "]",
                                GetLevelColor(level))
            << " ";
 
        // Context in cyan
        if (context.IsSet()) {
            oss << console.Colorize("[" + context.FullPath() + "]", AnsiColor::Cyan) << " ";
        }
 
        oss << message;
        return oss.str();
    }
 
  private:
    [[nodiscard]] static const char *GetLevelString(LogLevel level) {
        switch (level) {
        case LogLevel::Trace:
            return "TRC";
        case LogLevel::Debug:
            return "DBG";
        case LogLevel::Info:
            return "INF";
        case LogLevel::Event:
            return "EVT";
        case LogLevel::Warning:
            return "WRN";
        case LogLevel::Error:
            return "ERR";
        case LogLevel::Fatal:
            return "FTL";
        }
        return "???";
    }
 
    [[nodiscard]] static const char *GetLevelColor(LogLevel level) {
        switch (level) {
        case LogLevel::Trace:
            return AnsiColor::Gray;
        case LogLevel::Debug:
            return AnsiColor::Cyan;
        case LogLevel::Info:
            return AnsiColor::White;
        case LogLevel::Event:
            return AnsiColor::Green;
        case LogLevel::Warning:
            return AnsiColor::Yellow;
        case LogLevel::Error:
            return AnsiColor::Red;
        case LogLevel::Fatal:
            return AnsiColor::BgRed;
        }
        return AnsiColor::White;
    }
};
 
// =============================================================================
// LogContextManager
// =============================================================================

class LogContextManager {
  public:
    static void SetContext(const LogContext &ctx) { current_context_ = ctx; }

    static void ClearContext() { current_context_ = LogContext{}; }

    [[nodiscard]] static const LogContext &GetContext() { return current_context_; }

    class ScopedContext {
      public:
        ScopedContext(const std::string &entity, const std::string &component,
                      const std::string &type = "")
            : previous_(current_context_) {
            current_context_.entity = entity;
            current_context_.component = component;
            current_context_.type = type;
        }
 
        ~ScopedContext() { current_context_ = previous_; }
 
        // Non-copyable, non-movable
        ScopedContext(const ScopedContext &) = delete;
        ScopedContext &operator=(const ScopedContext &) = delete;
        ScopedContext(ScopedContext &&) = delete;
        ScopedContext &operator=(ScopedContext &&) = delete;
 
      private:
        LogContext previous_;
    };
 
  private:
    // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
    static inline thread_local LogContext current_context_;
};
 
// =============================================================================
// LogService
// =============================================================================

class LogService {
  public:
    using Sink = std::function<void(const std::vector<LogEntry> &)>;
 
    LogService() = default;
 
    // === Mode Control ===

    void SetImmediateMode(bool immediate) { immediate_mode_ = immediate; }
    [[nodiscard]] bool IsImmediateMode() const { return immediate_mode_; }

    class BufferedScope {
      public:
        explicit BufferedScope(LogService &service)
            : service_(service), previous_mode_(service.immediate_mode_) {
            service_.SetImmediateMode(false);
        }
 
        ~BufferedScope() {
            service_.FlushAndClear();
            service_.SetImmediateMode(previous_mode_);
        }
 
        // Non-copyable, non-movable
        BufferedScope(const BufferedScope &) = delete;
        BufferedScope &operator=(const BufferedScope &) = delete;
        BufferedScope(BufferedScope &&) = delete;
        BufferedScope &operator=(BufferedScope &&) = delete;
 
      private:
        LogService &service_;
        bool previous_mode_;
    };
 
    // === Configuration ===

    void SetMinLevel(LogLevel level) { min_level_ = level; }
    [[nodiscard]] LogLevel GetMinLevel() const { return min_level_; }

    void Reserve(std::size_t capacity) { entries_.reserve(capacity); }

    void AddSink(Sink sink) { sinks_.emplace_back(std::move(sink), LogLevel::Trace); }

    void AddSink(Sink sink, LogLevel min_level) { sinks_.emplace_back(std::move(sink), min_level); }

    void ClearSinks() { sinks_.clear(); }
 
    // === Logging API ===

    void Log(LogLevel level, double sim_time, std::string_view message) {
        Log(level, sim_time, message, LogContextManager::GetContext());
    }

    void Log(LogLevel level, double sim_time, std::string_view message, const LogContext &ctx) {
        if (level < min_level_) {
            return;
        }
 
        auto entry = LogEntry::Create(level, sim_time, message, ctx);
 
        std::lock_guard<std::mutex> lock(mutex_);
 
        // Track error counts (inside lock for thread safety)
        if (level == LogLevel::Error) {
            ++error_count_;
        } else if (level == LogLevel::Fatal) {
            ++fatal_count_;
        }
 
        entries_.push_back(std::move(entry));
 
        if (immediate_mode_) {
            FlushEntry(entries_.back());
        }
    }
 
    // Convenience methods (use thread-local context)
    void Trace(double t, std::string_view msg) { Log(LogLevel::Trace, t, msg); }
    void Debug(double t, std::string_view msg) { Log(LogLevel::Debug, t, msg); }
    void Info(double t, std::string_view msg) { Log(LogLevel::Info, t, msg); }
    void Event(double t, std::string_view msg) { Log(LogLevel::Event, t, msg); }
    void Warning(double t, std::string_view msg) { Log(LogLevel::Warning, t, msg); }
    void Error(double t, std::string_view msg) { Log(LogLevel::Error, t, msg); }
    void Fatal(double t, std::string_view msg) { Log(LogLevel::Fatal, t, msg); }
 
    // === Flush Control ===

    void Flush(bool sort_by_time = false) {
        std::lock_guard<std::mutex> lock(mutex_);
 
        if (entries_.empty()) {
            return;
        }
 
        if (sort_by_time) {
            std::sort(entries_.begin(), entries_.end(), [](const LogEntry &a, const LogEntry &b) {
                return a.wall_time < b.wall_time;
            });
        }
 
        for (const auto &[sink, min_level] : sinks_) {
            // Filter entries by sink's minimum level
            std::vector<LogEntry> filtered;
            filtered.reserve(entries_.size());
            for (const auto &entry : entries_) {
                if (entry.level >= min_level) {
                    filtered.push_back(entry);
                }
            }
            if (!filtered.empty()) {
                sink(filtered);
            }
        }
    }

    void FlushAndClear(bool sort_by_time = false) {
        Flush(sort_by_time);
        std::lock_guard<std::mutex> lock(mutex_);
        entries_.clear();
    }

    void Clear() {
        std::lock_guard<std::mutex> lock(mutex_);
        entries_.clear();
    }
 
    // === Query API ===
 
    [[nodiscard]] std::size_t PendingCount() const {
        std::lock_guard<std::mutex> lock(mutex_);
        return entries_.size();
    }
 
    [[nodiscard]] bool HasPending() const {
        std::lock_guard<std::mutex> lock(mutex_);
        return !entries_.empty();
    }
 
    [[nodiscard]] std::vector<LogEntry> GetPending() const {
        std::lock_guard<std::mutex> lock(mutex_);
        return entries_; // Return copy for thread safety
    }

    [[nodiscard]] bool HasErrors() const {
        std::lock_guard<std::mutex> lock(mutex_);
        return error_count_ > 0;
    }
 
    [[nodiscard]] bool HasFatalErrors() const {
        std::lock_guard<std::mutex> lock(mutex_);
        return fatal_count_ > 0;
    }
 
    [[nodiscard]] std::size_t ErrorCount() const {
        std::lock_guard<std::mutex> lock(mutex_);
        return error_count_;
    }
 
    [[nodiscard]] std::size_t FatalCount() const {
        std::lock_guard<std::mutex> lock(mutex_);
        return fatal_count_;
    }

    void ResetErrorCounts() {
        std::lock_guard<std::mutex> lock(mutex_);
        error_count_ = 0;
        fatal_count_ = 0;
    }
 
    // === Filtering (for query, not output) ===
 
    [[nodiscard]] std::vector<LogEntry> GetEntriesAtLevel(LogLevel level) const {
        std::lock_guard<std::mutex> lock(mutex_);
        std::vector<LogEntry> result;
        for (const auto &entry : entries_) {
            if (entry.level == level) {
                result.push_back(entry);
            }
        }
        return result;
    }
 
    [[nodiscard]] std::vector<LogEntry> GetEntriesForEntity(std::string_view entity) const {
        std::lock_guard<std::mutex> lock(mutex_);
        std::vector<LogEntry> result;
        for (const auto &entry : entries_) {
            if (entry.context.entity == entity) {
                result.push_back(entry);
            }
        }
        return result;
    }
 
    [[nodiscard]] std::vector<LogEntry> GetEntriesForComponent(std::string_view path) const {
        std::lock_guard<std::mutex> lock(mutex_);
        std::vector<LogEntry> result;
        for (const auto &entry : entries_) {
            if (entry.context.FullPath() == path) {
                result.push_back(entry);
            }
        }
        return result;
    }
 
  private:
    std::vector<LogEntry> entries_;
    std::vector<std::pair<Sink, LogLevel>> sinks_; 
    LogLevel min_level_ = LogLevel::Info;
    bool immediate_mode_ = true; 
 
    std::size_t error_count_ = 0;
    std::size_t fatal_count_ = 0;
 
    mutable std::mutex mutex_;
 
    void FlushEntry(const LogEntry &entry) {
        for (const auto &[sink, min_level] : sinks_) {
            if (entry.level >= min_level) {
                sink({entry});
            }
        }
    }
};

inline LogService &GetLogService() {
    static LogService instance;
    return instance;
}
 
} // namespace icarus
 
// =============================================================================
// Logging Macros
// =============================================================================
 
// NOLINTBEGIN(cppcoreguidelines-macro-usage)
#define ICARUS_LOG_TRACE(sim_time, msg) ::icarus::GetLogService().Trace(sim_time, msg)
 
#define ICARUS_LOG_DEBUG(sim_time, msg) ::icarus::GetLogService().Debug(sim_time, msg)
 
#define ICARUS_LOG_INFO(sim_time, msg) ::icarus::GetLogService().Info(sim_time, msg)
 
#define ICARUS_LOG_EVENT(sim_time, msg) ::icarus::GetLogService().Event(sim_time, msg)
 
#define ICARUS_LOG_WARN(sim_time, msg) ::icarus::GetLogService().Warning(sim_time, msg)
 
#define ICARUS_LOG_ERROR(sim_time, msg) ::icarus::GetLogService().Error(sim_time, msg)
 
#define ICARUS_LOG_FATAL(sim_time, msg) ::icarus::GetLogService().Fatal(sim_time, msg)
// NOLINTEND(cppcoreguidelines-macro-usage)