smartbotic/lib/logging/logger.cpp

#include "logging/logger.hpp"
#include <spdlog/sinks/basic_file_sink.h>

namespace smartbotic::logging {

std::shared_ptr<spdlog::logger> Logger::defaultLogger_ = nullptr;
bool Logger::initialized_ = false;

void Logger::init(const LogConfig& config) {
    if (initialized_) {
        return;
    }

    std::vector<spdlog::sink_ptr> sinks;

    // Console sink
    if (config.console) {
        auto console_sink = std::make_shared<spdlog::sinks::stdout_color_sink_mt>();
        console_sink->set_level(static_cast<spdlog::level::level_enum>(config.level));
        sinks.push_back(console_sink);
    }

    // File sink
    if (!config.file_path.empty()) {
        auto file_sink = std::make_shared<spdlog::sinks::rotating_file_sink_mt>(
            config.file_path, config.max_file_size, config.max_files);
        file_sink->set_level(static_cast<spdlog::level::level_enum>(config.level));
        sinks.push_back(file_sink);
    }

    // Create logger
    defaultLogger_ = std::make_shared<spdlog::logger>(config.name, sinks.begin(), sinks.end());
    defaultLogger_->set_level(static_cast<spdlog::level::level_enum>(config.level));
    defaultLogger_->set_pattern(config.pattern);

    // Register as default
    spdlog::set_default_logger(defaultLogger_);
    spdlog::flush_every(std::chrono::seconds(3));

    initialized_ = true;
}

void Logger::shutdown() {
    if (initialized_) {
        spdlog::shutdown();
        defaultLogger_.reset();
        initialized_ = false;
    }
}

std::shared_ptr<spdlog::logger> Logger::get(const std::string& name) {
    if (!initialized_) {
        // Initialize with defaults if not already initialized
        init(LogConfig{});
    }

    if (name.empty()) {
        return defaultLogger_;
    }

    auto logger = spdlog::get(name);
    if (!logger) {
        // Create a new logger with same sinks as default
        logger = defaultLogger_->clone(name);
        spdlog::register_logger(logger);
    }
    return logger;
}

void Logger::setLevel(LogLevel level) {
    if (defaultLogger_) {
        defaultLogger_->set_level(static_cast<spdlog::level::level_enum>(level));
    }
}

void Logger::flush() {
    if (defaultLogger_) {
        defaultLogger_->flush();
    }
}

ScopedLogger::ScopedLogger(const std::string& component)
    : logger_(Logger::get(component)) {}

} // namespace smartbotic::logging