Basic monitoring backend using internal metrics storage. More...

#include <fallback_monitoring_backend.h>

Inheritance diagram for database::integrated::adapters::backends::fallback_monitoring_backend:

Collaboration diagram for database::integrated::adapters::backends::fallback_monitoring_backend:

Public Member Functions
	fallback_monitoring_backend (const db_monitoring_config &config)

	~fallback_monitoring_backend () override

	fallback_monitoring_backend (const fallback_monitoring_backend &)=delete

fallback_monitoring_backend &	operator= (const fallback_monitoring_backend &)=delete

	fallback_monitoring_backend (fallback_monitoring_backend &&)=delete

fallback_monitoring_backend &	operator= (fallback_monitoring_backend &&)=delete

common::VoidResult	initialize () override
	Initialize the monitoring backend.

common::VoidResult	shutdown () override
	Shutdown the monitoring backend gracefully.

bool	is_initialized () const override
	Check if backend is initialized.

common::VoidResult	record_metric (const std::string &name, double value) override
	Record a metric value.

common::VoidResult	record_metric (const std::string &name, double value, const std::unordered_map< std::string, std::string > &tags) override
	Record a metric value with tags.

common::Result< metrics_snapshot >	get_metrics () override
	Get current metrics snapshot.

common::Result< health_check_result >	check_health () override
	Perform health check.

common::VoidResult	reset () override
	Reset all metrics.

void	record_query_execution (std::chrono::microseconds duration, bool success) override
	Record query execution.

void	record_connection_acquired () override
	Record connection acquisition.

void	record_connection_released () override
	Record connection release.

void	update_pool_stats (std::size_t active, std::size_t idle, std::size_t total) override
	Update connection pool statistics.

void	record_transaction_begin () override
	Record transaction begin.

void	record_transaction_commit () override
	Record transaction commit.

void	record_transaction_rollback () override
	Record transaction rollback.

common::Result< database_metrics >	get_database_metrics () override
	Get database-specific metrics.

std::string	export_prometheus_metrics () override
	Export metrics in Prometheus format.

Public Member Functions inherited from database::integrated::adapters::backends::monitoring_backend
virtual	~monitoring_backend ()=default

Private Member Functions
std::chrono::microseconds	calculate_percentile (double percentile)
	Calculate percentile from latency samples.

void	update_avg_latency ()
	Update average query latency.

Private Attributes
const db_monitoring_config &	config_

bool	initialized_

std::mutex	mutex_

std::chrono::steady_clock::time_point	start_time_

database_metrics	metrics_

std::vector< std::chrono::microseconds >	query_latencies_

std::unordered_map< std::string, double >	generic_metrics_

Detailed Description

Basic monitoring backend using internal metrics storage.

This backend provides simple monitoring when monitoring_system is unavailable. Stores metrics in memory and provides basic health checks.

Definition at line 45 of file fallback_monitoring_backend.h.

Constructor & Destructor Documentation

◆ fallback_monitoring_backend() [1/3]

database::integrated::adapters::backends::fallback_monitoring_backend::fallback_monitoring_backend ( const db_monitoring_config & config )

explicit

Definition at line 34 of file fallback_monitoring_backend.cpp.

    : config_(config), initialized_(false)
{
}

◆ ~fallback_monitoring_backend()

database::integrated::adapters::backends::fallback_monitoring_backend::~fallback_monitoring_backend ( )

override

Definition at line 39 of file fallback_monitoring_backend.cpp.

{
    if (initialized_)
    {
        shutdown();
    }
}

References initialized_, and shutdown().

Here is the call graph for this function:

◆ fallback_monitoring_backend() [2/3]

database::integrated::adapters::backends::fallback_monitoring_backend::fallback_monitoring_backend ( const fallback_monitoring_backend & )

delete

◆ fallback_monitoring_backend() [3/3]

database::integrated::adapters::backends::fallback_monitoring_backend::fallback_monitoring_backend ( fallback_monitoring_backend && )

delete

Member Function Documentation

◆ calculate_percentile()

std::chrono::microseconds database::integrated::adapters::backends::fallback_monitoring_backend::calculate_percentile ( double percentile )

private

Calculate percentile from latency samples.

Definition at line 307 of file fallback_monitoring_backend.cpp.

{
    if (query_latencies_.empty())
    {
        return std::chrono::microseconds(0);
    }
 
    auto sorted = query_latencies_;
    std::sort(sorted.begin(), sorted.end());
 
    size_t idx = static_cast<size_t>(sorted.size() * percentile);
    if (idx >= sorted.size())
    {
        idx = sorted.size() - 1;
    }
 
    return sorted[idx];
}

References query_latencies_.

◆ check_health()

common::Result< health_check_result > database::integrated::adapters::backends::fallback_monitoring_backend::check_health ( )

overridevirtual

Perform health check.

Returns: Health check result

Implements database::integrated::adapters::backends::monitoring_backend.

Definition at line 137 of file fallback_monitoring_backend.cpp.

{
    if (!initialized_)
    {
        return make_error_result<health_check_result>("Monitoring backend not initialized");
    }
 
    std::lock_guard<std::mutex> lock(mutex_);
 
    health_check_result result;
    result.status = health_status::healthy;
    result.message = "Database system healthy";
 
    // Connection pool health check
    if (metrics_.connection_usage_percent > config_.connection_usage_warning_threshold * 100.0)
    {
        result.status = health_status::degraded;
        result.message = "Connection pool usage critical";
        result.metadata["connection_usage"] = std::to_string(metrics_.connection_usage_percent) + "%";
    }
 
    // Query latency health check
    if (metrics_.avg_query_latency > config_.query_latency_warning)
    {
        result.status = health_status::degraded;
        result.message = "Query latency critical";
        result.metadata["avg_latency_us"] = std::to_string(metrics_.avg_query_latency.count());
    }
 
    // Query success rate health check
    if (metrics_.total_queries > 10 && metrics_.query_success_rate < 0.95)
    {
        result.status = health_status::degraded;
        result.message = "Query success rate low";
        result.metadata["success_rate"] = std::to_string(metrics_.query_success_rate);
    }
 
    return result;
}

◆ export_prometheus_metrics()

std::string database::integrated::adapters::backends::fallback_monitoring_backend::export_prometheus_metrics ( )

overridevirtual

Export metrics in Prometheus format.

Returns: Prometheus-formatted metrics string

Implements database::integrated::adapters::backends::monitoring_backend.

Definition at line 284 of file fallback_monitoring_backend.cpp.

{
    std::lock_guard<std::mutex> lock(mutex_);
 
    std::ostringstream oss;
    oss << "# TYPE db_connections_active gauge\n";
    oss << "db_connections_active " << metrics_.active_connections << "\n";
 
    oss << "# TYPE db_connections_idle gauge\n";
    oss << "db_connections_idle " << metrics_.idle_connections << "\n";
 
    oss << "# TYPE db_queries_total counter\n";
    oss << "db_queries_total " << metrics_.total_queries << "\n";
 
    oss << "# TYPE db_queries_success_rate gauge\n";
    oss << "db_queries_success_rate " << metrics_.query_success_rate << "\n";
 
    oss << "# TYPE db_query_latency_avg_us gauge\n";
    oss << "db_query_latency_avg_us " << metrics_.avg_query_latency.count() << "\n";
 
    return oss.str();
}

References database::integrated::adapters::database_metrics::active_connections, database::integrated::adapters::database_metrics::avg_query_latency, database::integrated::adapters::database_metrics::idle_connections, metrics_, mutex_, database::integrated::adapters::database_metrics::query_success_rate, and database::integrated::adapters::database_metrics::total_queries.

◆ get_database_metrics()

common::Result< database_metrics > database::integrated::adapters::backends::fallback_monitoring_backend::get_database_metrics ( )

overridevirtual

Get database-specific metrics.

Returns: Database metrics on success

Implements database::integrated::adapters::backends::monitoring_backend.

Definition at line 272 of file fallback_monitoring_backend.cpp.

{
    if (!initialized_)
    {
        return make_error_result<database_metrics>("Monitoring backend not initialized");
    }
 
    std::lock_guard<std::mutex> lock(mutex_);
    metrics_.timestamp = std::chrono::system_clock::now();
    return metrics_;
}

References initialized_, metrics_, mutex_, and database::integrated::adapters::database_metrics::timestamp.

◆ get_metrics()

common::Result< metrics_snapshot > database::integrated::adapters::backends::fallback_monitoring_backend::get_metrics ( )

overridevirtual

Get current metrics snapshot.

Returns: Metrics snapshot on success

Implements database::integrated::adapters::backends::monitoring_backend.

Definition at line 99 of file fallback_monitoring_backend.cpp.

{
    if (!initialized_)
    {
        return make_error_result<metrics_snapshot>("Monitoring backend not initialized");
    }
 
    std::lock_guard<std::mutex> lock(mutex_);
 
    metrics_snapshot snapshot;
    snapshot.source_id = "database_fallback";
 
    // Connection metrics
    snapshot.gauges["db.connections.active"] = static_cast<double>(metrics_.active_connections);
    snapshot.gauges["db.connections.idle"] = static_cast<double>(metrics_.idle_connections);
    snapshot.gauges["db.connections.usage_percent"] = metrics_.connection_usage_percent;
 
    // Query metrics
    snapshot.gauges["db.query.avg_latency_us"] = static_cast<double>(metrics_.avg_query_latency.count());
    snapshot.gauges["db.query.success_rate"] = metrics_.query_success_rate;
 
    snapshot.counters["db.queries.total"] = metrics_.total_queries;
    snapshot.counters["db.queries.successful"] = metrics_.successful_queries;
    snapshot.counters["db.queries.failed"] = metrics_.failed_queries;
 
    // Transaction metrics
    snapshot.counters["db.transactions.committed"] = metrics_.committed_transactions;
    snapshot.counters["db.transactions.rolled_back"] = metrics_.rolled_back_transactions;
 
    // Generic metrics
    for (const auto& [name, value] : generic_metrics_)
    {
        snapshot.gauges[name] = value;
    }
 
    return snapshot;
}

◆ initialize()

common::VoidResult database::integrated::adapters::backends::fallback_monitoring_backend::initialize ( )

overridevirtual

Initialize the monitoring backend.

Returns: VoidResult::ok() on success, error on failure

Implements database::integrated::adapters::backends::monitoring_backend.

Definition at line 47 of file fallback_monitoring_backend.cpp.

{
    if (initialized_)
    {
        return common::ok();
    }
 
    start_time_ = std::chrono::steady_clock::now();
    initialized_ = true;
    return common::ok();
}

References initialized_, common::ok(), and start_time_.

Here is the call graph for this function:

◆ is_initialized()

bool database::integrated::adapters::backends::fallback_monitoring_backend::is_initialized ( ) const

overridevirtual

Check if backend is initialized.

Returns: true if initialized and ready

Implements database::integrated::adapters::backends::monitoring_backend.

Definition at line 74 of file fallback_monitoring_backend.cpp.

{
    return initialized_;
}

References initialized_.

◆ operator=() [1/2]

fallback_monitoring_backend & database::integrated::adapters::backends::fallback_monitoring_backend::operator= ( const fallback_monitoring_backend & )

delete

◆ operator=() [2/2]

fallback_monitoring_backend & database::integrated::adapters::backends::fallback_monitoring_backend::operator= ( fallback_monitoring_backend && )

delete

◆ record_connection_acquired()

void database::integrated::adapters::backends::fallback_monitoring_backend::record_connection_acquired ( )

overridevirtual

Record connection acquisition.

Implements database::integrated::adapters::backends::monitoring_backend.

Definition at line 222 of file fallback_monitoring_backend.cpp.

{
    // Handled by update_pool_stats
}

◆ record_connection_released()

void database::integrated::adapters::backends::fallback_monitoring_backend::record_connection_released ( )

overridevirtual

Record connection release.

Implements database::integrated::adapters::backends::monitoring_backend.

Definition at line 227 of file fallback_monitoring_backend.cpp.

{
    // Handled by update_pool_stats
}

◆ record_metric() [1/2]

common::VoidResult database::integrated::adapters::backends::fallback_monitoring_backend::record_metric	(	const std::string &	name,
		double	value )

overridevirtual

Record a metric value.

Parameters

name	Metric name
value	Metric value

Returns: VoidResult::ok() on success

Implements database::integrated::adapters::backends::monitoring_backend.

Definition at line 79 of file fallback_monitoring_backend.cpp.

{
    if (!initialized_)
    {
        return make_error("Monitoring backend not initialized");
    }
 
    std::lock_guard<std::mutex> lock(mutex_);
    generic_metrics_[name] = value;
    return common::ok();
}

References generic_metrics_, initialized_, mutex_, and common::ok().

Referenced by record_metric().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ record_metric() [2/2]

common::VoidResult database::integrated::adapters::backends::fallback_monitoring_backend::record_metric	(	const std::string &	name,
		double	value,
		const std::unordered_map< std::string, std::string > &	tags )

overridevirtual

Record a metric value with tags.

Parameters

name	Metric name
value	Metric value
tags	Metric tags/labels

Returns: VoidResult::ok() on success

Implements database::integrated::adapters::backends::monitoring_backend.

Definition at line 91 of file fallback_monitoring_backend.cpp.

{
    // Fallback ignores tags
    return record_metric(name, value);
}

References record_metric().

Here is the call graph for this function:

◆ record_query_execution()

void database::integrated::adapters::backends::fallback_monitoring_backend::record_query_execution	(	std::chrono::microseconds	duration,
		bool	success )

overridevirtual

Record query execution.

Parameters

duration	Query execution duration
success	Whether query succeeded

Implements database::integrated::adapters::backends::monitoring_backend.

Definition at line 191 of file fallback_monitoring_backend.cpp.

{
    std::lock_guard<std::mutex> lock(mutex_);
 
    metrics_.total_queries++;
    if (success)
    {
        metrics_.successful_queries++;
    }
    else
    {
        metrics_.failed_queries++;
    }
 
    if (metrics_.total_queries > 0)
    {
        metrics_.query_success_rate = static_cast<double>(metrics_.successful_queries) / metrics_.total_queries;
    }
 
    query_latencies_.push_back(duration);
 
    // Keep last 1000 samples
    const size_t max_samples = 1000;
    if (query_latencies_.size() > max_samples)
    {
        query_latencies_.erase(query_latencies_.begin());
    }
 
    update_avg_latency();
}

References database::integrated::adapters::database_metrics::failed_queries, metrics_, mutex_, query_latencies_, database::integrated::adapters::database_metrics::query_success_rate, database::success, database::integrated::adapters::database_metrics::successful_queries, database::integrated::adapters::database_metrics::total_queries, and update_avg_latency().

Here is the call graph for this function:

◆ record_transaction_begin()

void database::integrated::adapters::backends::fallback_monitoring_backend::record_transaction_begin ( )

overridevirtual

Record transaction begin.

Implements database::integrated::adapters::backends::monitoring_backend.

Definition at line 246 of file fallback_monitoring_backend.cpp.

{
    std::lock_guard<std::mutex> lock(mutex_);
    metrics_.active_transactions++;
}

References database::integrated::adapters::database_metrics::active_transactions, metrics_, and mutex_.

◆ record_transaction_commit()

void database::integrated::adapters::backends::fallback_monitoring_backend::record_transaction_commit ( )

overridevirtual

Record transaction commit.

Implements database::integrated::adapters::backends::monitoring_backend.

Definition at line 252 of file fallback_monitoring_backend.cpp.

{
    std::lock_guard<std::mutex> lock(mutex_);
    if (metrics_.active_transactions > 0)
    {
        metrics_.active_transactions--;
    }
    metrics_.committed_transactions++;
}

References database::integrated::adapters::database_metrics::active_transactions, database::integrated::adapters::database_metrics::committed_transactions, metrics_, and mutex_.

◆ record_transaction_rollback()

void database::integrated::adapters::backends::fallback_monitoring_backend::record_transaction_rollback ( )

overridevirtual

Record transaction rollback.

Implements database::integrated::adapters::backends::monitoring_backend.

Definition at line 262 of file fallback_monitoring_backend.cpp.

{
    std::lock_guard<std::mutex> lock(mutex_);
    if (metrics_.active_transactions > 0)
    {
        metrics_.active_transactions--;
    }
    metrics_.rolled_back_transactions++;
}

References database::integrated::adapters::database_metrics::active_transactions, metrics_, mutex_, and database::integrated::adapters::database_metrics::rolled_back_transactions.

◆ reset()

common::VoidResult database::integrated::adapters::backends::fallback_monitoring_backend::reset ( )

overridevirtual

Reset all metrics.

Returns: VoidResult::ok() on success

Implements database::integrated::adapters::backends::monitoring_backend.

Definition at line 177 of file fallback_monitoring_backend.cpp.

{
    if (!initialized_)
    {
        return make_error("Monitoring backend not initialized");
    }
 
    std::lock_guard<std::mutex> lock(mutex_);
    metrics_ = database_metrics{};
    query_latencies_.clear();
    generic_metrics_.clear();
    return common::ok();
}

References generic_metrics_, initialized_, metrics_, mutex_, common::ok(), and query_latencies_.

Here is the call graph for this function:

◆ shutdown()

common::VoidResult database::integrated::adapters::backends::fallback_monitoring_backend::shutdown ( )

overridevirtual

Shutdown the monitoring backend gracefully.

Returns: VoidResult::ok() on success, error on failure

Implements database::integrated::adapters::backends::monitoring_backend.

Definition at line 59 of file fallback_monitoring_backend.cpp.

{
    if (!initialized_)
    {
        return common::ok();
    }
 
    std::lock_guard<std::mutex> lock(mutex_);
    metrics_ = database_metrics{};
    query_latencies_.clear();
    generic_metrics_.clear();
    initialized_ = false;
    return common::ok();
}

References generic_metrics_, initialized_, metrics_, mutex_, common::ok(), and query_latencies_.

Referenced by ~fallback_monitoring_backend().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ update_avg_latency()

void database::integrated::adapters::backends::fallback_monitoring_backend::update_avg_latency ( )

private

Update average query latency.

Definition at line 326 of file fallback_monitoring_backend.cpp.

{
    if (query_latencies_.empty())
    {
        return;
    }
 
    auto sum = std::accumulate(
        query_latencies_.begin(), query_latencies_.end(), std::chrono::microseconds(0));
    metrics_.avg_query_latency = std::chrono::microseconds(sum.count() / query_latencies_.size());
 
    metrics_.min_query_latency = *std::min_element(query_latencies_.begin(), query_latencies_.end());
    metrics_.max_query_latency = *std::max_element(query_latencies_.begin(), query_latencies_.end());
 
    auto sorted = query_latencies_;
    std::sort(sorted.begin(), sorted.end());
 
    size_t p95_idx = static_cast<size_t>(sorted.size() * 0.95);
    size_t p99_idx = static_cast<size_t>(sorted.size() * 0.99);
 
    if (p95_idx < sorted.size())
    {
        metrics_.p95_query_latency = sorted[p95_idx];
    }
    if (p99_idx < sorted.size())
    {
        metrics_.p99_query_latency = sorted[p99_idx];
    }
}

References database::integrated::adapters::database_metrics::avg_query_latency, database::integrated::adapters::database_metrics::max_query_latency, metrics_, database::integrated::adapters::database_metrics::min_query_latency, database::integrated::adapters::database_metrics::p95_query_latency, database::integrated::adapters::database_metrics::p99_query_latency, and query_latencies_.

Referenced by record_query_execution().

Here is the caller graph for this function:

◆ update_pool_stats()

void database::integrated::adapters::backends::fallback_monitoring_backend::update_pool_stats	(	std::size_t	active,
		std::size_t	idle,
		std::size_t	total )

overridevirtual

Update connection pool statistics.

Parameters

active	Number of active connections
idle	Number of idle connections
total	Total pool size

Implements database::integrated::adapters::backends::monitoring_backend.

Definition at line 232 of file fallback_monitoring_backend.cpp.

{
    std::lock_guard<std::mutex> lock(mutex_);
 
    metrics_.active_connections = active;
    metrics_.idle_connections = idle;
    metrics_.total_connections = total;
 
    if (total > 0)
    {
        metrics_.connection_usage_percent = (static_cast<double>(active) / total) * 100.0;
    }
}