logger_adapter.h

Go to the documentation of this file.

// BSD 3-Clause License
// Copyright (c) 2025, 🍀☀🌕🌥 🌊
// See the LICENSE file in the project root for full license information.
 
#pragma once
 
#include "../core/configuration.h"
 
#include <chrono>
#include <cstddef>
#include <memory>
#include <string>
 
// Use common Result pattern from shared header
#include "../core/common_result.h"
 
// Forward declare backend interface
namespace database::integrated::adapters::backends
{
    class logger_backend;
}
 
namespace database
{
namespace integrated
{
namespace adapters
{
 
enum class logger_backend_type
{
    auto_select,  
    system,       
    fallback,     
    null          
};
 
class logger_adapter
{
public:
    explicit logger_adapter(
        const db_logger_config& config,
        logger_backend_type backend_type = logger_backend_type::auto_select);
 
    ~logger_adapter();
 
    // Non-copyable
    logger_adapter(const logger_adapter&) = delete;
    logger_adapter& operator=(const logger_adapter&) = delete;
 
    // Move constructor only (const reference member prevents move assignment)
    logger_adapter(logger_adapter&&) noexcept;
    logger_adapter& operator=(logger_adapter&&) = delete;
 
    common::VoidResult initialize();
 
    common::VoidResult shutdown();
 
    bool is_initialized() const;
 
    // ═══════════════════════════════════════════════════════════════
    // Database-Specific Logging Methods
    // ═══════════════════════════════════════════════════════════════
 
    void log_query(db_log_level level, const std::string& query, std::chrono::microseconds duration);
 
    void log_slow_query(const std::string& query, std::chrono::microseconds duration,
        std::chrono::milliseconds threshold);
 
    void log_connection_event(const std::string& event, const std::string& details);
 
    void log_transaction(const std::string& operation, bool success, const std::string& details);
 
    void log_pool_event(const std::string& event, std::size_t active, std::size_t idle);
 
    void log_error(const std::string& operation, const std::string& error_msg,
        const std::string& sql_state = "");
 
    // ═══════════════════════════════════════════════════════════════
    // Generic Logging
    // ═══════════════════════════════════════════════════════════════
 
    void log(db_log_level level, const std::string& message);
 
    void flush();
 
private:
    static std::unique_ptr<backends::logger_backend> create_backend(
        const db_logger_config& config,
        logger_backend_type backend_type);
 
    const db_logger_config& config_;
    std::unique_ptr<backends::logger_backend> backend_; 
};
 
} // namespace adapters
} // namespace integrated
} // namespace database