Logger.h

Go to the documentation of this file.

#pragma once
 
#include "Types/Types.h"
#include <chrono>
#include <functional>
#include <map>
#include <memory>
#include <vector>
// Removed ITab.h dependency - this is now in EmberForge application layer
 
namespace EmberCore {

enum class LogLevel {
    All = 0,     // Show all messages (equivalent to Trace)
    Trace = 1,   // Detailed trace information
    Info = 2,    // General information messages
    Warning = 3, // Warning messages
    Error = 4,   // Error messages
    Critical = 5 // Critical system errors
};

struct LogEntry {
    std::chrono::system_clock::time_point timestamp;
    LogLevel level;
    EmberCore::String category;
    EmberCore::String message;
    EmberCore::String formatted_message;
 
    LogEntry(LogLevel lvl, const EmberCore::String &cat, const EmberCore::String &msg);
    EmberCore::String FormatMessage() const;
    EmberCore::Color GetLevelColor() const;
    EmberCore::String GetLevelString() const;
};

class Logger {
  public:
    Logger();
    ~Logger() = default;
 
    // Logging methods
    void Trace(const EmberCore::String &category, const EmberCore::String &message);
    void Info(const EmberCore::String &category, const EmberCore::String &message);
    void Warning(const EmberCore::String &category, const EmberCore::String &message);
    void Error(const EmberCore::String &category, const EmberCore::String &message);
    void Critical(const EmberCore::String &category, const EmberCore::String &message);
 
    // Generic log method
    void Log(LogLevel level, const EmberCore::String &category, const EmberCore::String &message);
 
    // Configuration
    void SetMinLogLevel(LogLevel level) { min_log_level_ = level; }
    LogLevel GetMinLogLevel() const { return min_log_level_; }
 
    void SetMaxEntries(size_t max_entries) { max_entries_ = max_entries; }
    size_t GetMaxEntries() const { return max_entries_; }
 
    // Unified logging configuration (controls spdlog integration)
    void SetConsoleLoggingEnabled(bool enabled) { console_logging_enabled_ = enabled; }
    bool IsConsoleLoggingEnabled() const { return console_logging_enabled_; }
 
    void SetFileLoggingEnabled(bool enabled) { file_logging_enabled_ = enabled; }
    bool IsFileLoggingEnabled() const { return file_logging_enabled_; }
 
    // Console color control
    void SetConsoleColorsEnabled(bool enabled);
 
    // Entry management
    const std::vector<std::shared_ptr<LogEntry>> &GetEntries() const { return entries_; }
    void ClearEntries();
 
    // Filtering
    std::vector<std::shared_ptr<LogEntry>> GetFilteredEntries(LogLevel level_filter = LogLevel::All,
                                                              const EmberCore::String &category_filter = "",
                                                              const EmberCore::String &search_text = "") const;
 
    // Observer pattern for UI updates
    // Returns an observer ID that can be used to remove the observer later
    using ObserverId = size_t;
    ObserverId AddObserver(std::function<void()> observer);
    void RemoveObserver(ObserverId id);
 
    // Singleton access (optional)
    static Logger &GetInstance();
 
  private:
    void NotifyObservers();
    void TrimEntries();
 
    std::vector<std::shared_ptr<LogEntry>> entries_;
    LogLevel min_log_level_ = LogLevel::All;
    size_t max_entries_ = 1000;
    std::map<ObserverId, std::function<void()>> observers_;
    ObserverId next_observer_id_ = 1;
 
    // Unified logging configuration
    bool console_logging_enabled_ = true; // Enable console output via spdlog
    bool file_logging_enabled_ = true;    // Enable file output via spdlog
};
 
// LogPanel class moved to EmberForge application layer
// (was wxWidgets-dependent and used ITab interface)
 
// Unified logging macros - logs to console/file via spdlog
#define LOG_TRACE(category, message) EmberCore::Logger::GetInstance().Trace(category, message)
#define LOG_INFO(category, message) EmberCore::Logger::GetInstance().Info(category, message)
#define LOG_WARNING(category, message) EmberCore::Logger::GetInstance().Warning(category, message)
#define LOG_ERROR(category, message) EmberCore::Logger::GetInstance().Error(category, message)
#define LOG_CRITICAL(category, message) EmberCore::Logger::GetInstance().Critical(category, message)
 
} // namespace EmberCore