monitoring_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 <cstdint>
#include <memory>
#include <string>
#include <unordered_map>
 
// Use common Result pattern from shared header
#include "../core/common_result.h"
 
// Include backend interface for complete types needed by Result<>
#include "backends/monitoring_backend.h"
 
// Forward declare backend class only
namespace database::integrated::adapters::backends
{
    class monitoring_backend;
}
 
namespace database
{
namespace integrated
{
namespace adapters
{
 
enum class monitoring_backend_type
{
    auto_select,  
    system,       
    fallback,     
    null          
};
 
struct database_metrics
{
    // Connection pool metrics
    std::size_t active_connections{ 0 };    
    std::size_t idle_connections{ 0 };      
    std::size_t total_connections{ 0 };     
    double connection_usage_percent{ 0.0 }; 
 
    // Query performance metrics
    std::uint64_t total_queries{ 0 };     
    std::uint64_t successful_queries{ 0 }; 
    std::uint64_t failed_queries{ 0 };    
    double query_success_rate{ 0.0 };     
 
    // Latency metrics
    std::chrono::microseconds avg_query_latency{ 0 }; 
    std::chrono::microseconds min_query_latency{ 0 }; 
    std::chrono::microseconds max_query_latency{ 0 }; 
    std::chrono::microseconds p95_query_latency{ 0 }; 
    std::chrono::microseconds p99_query_latency{ 0 }; 
 
    // Transaction metrics
    std::uint64_t active_transactions{ 0 };    
    std::uint64_t committed_transactions{ 0 };  
    std::uint64_t rolled_back_transactions{ 0 }; 
    double transaction_commit_rate{ 0.0 };      
 
    // Throughput metrics
    double queries_per_second{ 0.0 };      
    double transactions_per_second{ 0.0 }; 
 
    // Timestamp
    std::chrono::system_clock::time_point timestamp; 
};
 
class monitoring_adapter
{
public:
    explicit monitoring_adapter(
        const db_monitoring_config& config,
        monitoring_backend_type backend_type = monitoring_backend_type::auto_select);
 
    ~monitoring_adapter();
 
    // Non-copyable
    monitoring_adapter(const monitoring_adapter&) = delete;
    monitoring_adapter& operator=(const monitoring_adapter&) = delete;
 
    // Move constructor only (const reference member prevents move assignment)
    monitoring_adapter(monitoring_adapter&&) noexcept;
    monitoring_adapter& operator=(monitoring_adapter&&) = delete;
 
    common::VoidResult initialize();
 
    common::VoidResult shutdown();
 
    bool is_initialized() const;
 
    // ═══════════════════════════════════════════════════════════════
    // Monitoring Interface
    // ═══════════════════════════════════════════════════════════════
 
    common::VoidResult record_metric(const std::string& name, double value);
 
    common::VoidResult record_metric(
        const std::string& name, double value,
        const std::unordered_map<std::string, std::string>& tags);
 
    common::Result<backends::metrics_snapshot> get_metrics();
 
    common::Result<backends::health_check_result> check_health();
 
    common::VoidResult reset();
 
    // ═══════════════════════════════════════════════════════════════
    // Database-Specific Monitoring Methods
    // ═══════════════════════════════════════════════════════════════
 
    void record_query_execution(std::chrono::microseconds duration, bool success);
 
    void record_connection_acquired();
 
    void record_connection_released();
 
    void update_pool_stats(std::size_t active, std::size_t idle, std::size_t total);
 
    void record_transaction_begin();
 
    void record_transaction_commit();
 
    void record_transaction_rollback();
 
    common::Result<database_metrics> get_database_metrics();
 
    std::string export_prometheus_metrics();
 
private:
    static std::unique_ptr<backends::monitoring_backend> create_backend(
        const db_monitoring_config& config,
        monitoring_backend_type backend_type);
 
    const db_monitoring_config& config_;
    std::unique_ptr<backends::monitoring_backend> backend_; 
};
 
} // namespace adapters
} // namespace integrated
} // namespace database