Logger.cpp

Go to the documentation of this file.

#include "Utils/Logger.h"
#include "Utils/SpdlogManager.h"
#include <algorithm>
#include <iomanip>
#include <iostream>
#include <sstream>
 
#ifdef HAVE_SPDLOG
#include <spdlog/spdlog.h>
#endif
 
namespace EmberCore {
 
#ifdef HAVE_SPDLOG
// Helper function to convert Ember LogLevel to spdlog level
spdlog::level::level_enum ConvertToSpdlogLevel(LogLevel level) {
    switch (level) {
    case LogLevel::All:
    case LogLevel::Trace:
        return spdlog::level::trace;
    case LogLevel::Info:
        return spdlog::level::info;
    case LogLevel::Warning:
        return spdlog::level::warn;
    case LogLevel::Error:
        return spdlog::level::err;
    case LogLevel::Critical:
        return spdlog::level::critical;
    default:
        return spdlog::level::info;
    }
}
#endif
 
// LogEntry Implementation
LogEntry::LogEntry(LogLevel lvl, const EmberCore::String &cat, const EmberCore::String &msg)
    : timestamp(std::chrono::system_clock::now()), level(lvl), category(cat), message(msg),
      formatted_message(FormatMessage()) {}
 
EmberCore::String LogEntry::FormatMessage() const {
    // Format timestamp
    auto time_t = std::chrono::system_clock::to_time_t(timestamp);
    auto ms = std::chrono::duration_cast<std::chrono::milliseconds>(timestamp.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();
 
    EmberCore::String time_str = ss.str();
 
    // Format the complete message
    return "[" + time_str + "] [" + GetLevelString() + "] [" + category + "] " + message;
}
 
EmberCore::Color LogEntry::GetLevelColor() const {
    switch (level) {
    case LogLevel::Trace:
        return EmberCore::Color::Gray;
    case LogLevel::Info:
        return EmberCore::Color::White;
    case LogLevel::Warning:
        return EmberCore::Color::Yellow;
    case LogLevel::Error:
        return EmberCore::Color::Red;
    case LogLevel::Critical:
        return EmberCore::Color::Magenta;
    default:
        return EmberCore::Color::White;
    }
}
 
EmberCore::String LogEntry::GetLevelString() const {
    switch (level) {
    case LogLevel::Trace:
        return "TRACE";
    case LogLevel::Info:
        return "INFO";
    case LogLevel::Warning:
        return "WARN";
    case LogLevel::Error:
        return "ERROR";
    case LogLevel::Critical:
        return "CRITICAL";
    default:
        return "UNKNOWN";
    }
}
 
// Logger Implementation
Logger::Logger() : max_entries_(1000), console_logging_enabled_(true), file_logging_enabled_(true) {
// Initialize spdlog if available
#ifdef HAVE_SPDLOG
    try {
        SpdlogManager::GetInstance().Initialize();
    } catch (const std::exception &e) {
        // spdlog initialization failed, continue without it
    }
#endif
}
 
void Logger::Trace(const EmberCore::String &category, const EmberCore::String &message) {
    Log(LogLevel::Trace, category, message);
}
 
void Logger::Info(const EmberCore::String &category, const EmberCore::String &message) {
    Log(LogLevel::Info, category, message);
}
 
void Logger::Warning(const EmberCore::String &category, const EmberCore::String &message) {
    Log(LogLevel::Warning, category, message);
}
 
void Logger::Error(const EmberCore::String &category, const EmberCore::String &message) {
    Log(LogLevel::Error, category, message);
}
 
void Logger::Critical(const EmberCore::String &category, const EmberCore::String &message) {
    Log(LogLevel::Critical, category, message);
}
 
void Logger::Log(LogLevel level, const EmberCore::String &category, const EmberCore::String &message) {
    // Create log entry
    auto entry = std::make_shared<LogEntry>(level, category, message);
 
    // Add to entries list
    entries_.push_back(entry);
 
    // Maintain max entries limit
    TrimEntries();
 
    // Log to console if enabled
    if (console_logging_enabled_) {
#ifdef HAVE_SPDLOG
        try {
            auto spdlog_level = ConvertToSpdlogLevel(level);
            // Only log if the message meets the configured log level threshold
            if (spdlog_level >= spdlog::default_logger()->level()) {
                spdlog::log(spdlog_level, "[{}] {}", category, message);
            }
        } catch (const std::exception &e) {
            // spdlog failed, fall back to std::cout
            std::cout << entry->FormatMessage() << std::endl;
        }
#else
        std::cout << entry->FormatMessage() << std::endl;
#endif
    }
 
    // Log to file if enabled
    if (file_logging_enabled_) {
#ifdef HAVE_SPDLOG
        try {
            auto spdlog_level = ConvertToSpdlogLevel(level);
            // Only log if the message meets the configured log level threshold
            if (spdlog_level >= spdlog::default_logger()->level()) {
                spdlog::log(spdlog_level, "[{}] {}", category, message);
            }
        } catch (const std::exception &e) {
            // spdlog failed, fall back to std::cout
            std::cout << entry->FormatMessage() << std::endl;
        }
#endif
    }
 
    // Notify observers
    NotifyObservers();
}
 
std::vector<std::shared_ptr<LogEntry>> Logger::GetFilteredEntries(LogLevel level_filter,
                                                                  const EmberCore::String &category_filter,
                                                                  const EmberCore::String &search_text) const {
 
    std::vector<std::shared_ptr<LogEntry>> filtered;
 
    for (const auto &entry : entries_) {
        // Filter by level - if not "All", show only exact level match
        if (level_filter != LogLevel::All && entry->level != level_filter) {
            continue;
        }
 
        // Filter by category
        if (!category_filter.empty()) {
            std::string entry_cat_lower = entry->category;
            std::string filter_lower = category_filter;
            std::transform(entry_cat_lower.begin(), entry_cat_lower.end(), entry_cat_lower.begin(), ::tolower);
            std::transform(filter_lower.begin(), filter_lower.end(), filter_lower.begin(), ::tolower);
 
            if (entry_cat_lower.find(filter_lower) == std::string::npos) {
                continue;
            }
        }
 
        // Filter by search text
        if (!search_text.empty()) {
            std::string entry_msg_lower = entry->message;
            std::string entry_cat_lower = entry->category;
            std::string search_lower = search_text;
            std::transform(entry_msg_lower.begin(), entry_msg_lower.end(), entry_msg_lower.begin(), ::tolower);
            std::transform(entry_cat_lower.begin(), entry_cat_lower.end(), entry_cat_lower.begin(), ::tolower);
            std::transform(search_lower.begin(), search_lower.end(), search_lower.begin(), ::tolower);
 
            if (entry_msg_lower.find(search_lower) == std::string::npos &&
                entry_cat_lower.find(search_lower) == std::string::npos) {
                continue;
            }
        }
 
        filtered.push_back(entry);
    }
 
    return filtered;
}
 
void Logger::ClearEntries() { entries_.clear(); }
 
Logger::ObserverId Logger::AddObserver(std::function<void()> observer) {
    ObserverId id = next_observer_id_++;
    observers_[id] = observer;
    return id;
}
 
void Logger::RemoveObserver(ObserverId id) { observers_.erase(id); }
 
void Logger::NotifyObservers() {
    for (auto &pair : observers_) {
        try {
            pair.second();
        } catch (const std::exception &e) {
            // Observer failed, continue with others
        }
    }
}
 
void Logger::TrimEntries() {
    if (entries_.size() > max_entries_) {
        entries_.erase(entries_.begin(), entries_.begin() + (entries_.size() - max_entries_));
    }
}
 
void Logger::SetConsoleColorsEnabled(bool enabled) {
#ifdef HAVE_SPDLOG
    try {
        SpdlogManager::GetInstance().SetConsoleColorsEnabled(enabled);
    } catch (const std::exception &e) {
        // Failed to update console colors
    }
#endif
}
 
// Static instance
Logger &Logger::GetInstance() {
    static Logger instance;
    return instance;
}
 
} // namespace EmberCore