Performance metrics for connection pools. More...

#include <pool_metrics.h>

Collaboration diagram for database::monitoring::pool_metrics:

Public Member Functions
void	record_acquisition (uint64_t wait_time_us, bool success)
	Record a connection acquisition.

void	record_timeout ()
	Record a timeout event.

void	update_active (int delta)
	Update current active connection count.

void	update_queued (int delta)
	Update current queued request count.

void	record_health_check (uint64_t removed_connections=0)
	Record a health check operation.

double	average_wait_time_us () const
	Calculate average wait time.

double	success_rate () const
	Calculate success rate.

void	reset ()
	Reset all metrics.

Public Attributes
std::atomic< uint64_t >	total_acquisitions {0}

std::atomic< uint64_t >	successful_acquisitions {0}

std::atomic< uint64_t >	failed_acquisitions {0}

std::atomic< uint64_t >	timeouts {0}

std::atomic< uint64_t >	total_wait_time_us {0}

std::atomic< uint64_t >	min_wait_time_us {UINT64_MAX}

std::atomic< uint64_t >	max_wait_time_us {0}

std::atomic< uint64_t >	current_active {0}

std::atomic< uint64_t >	current_queued {0}

std::atomic< uint64_t >	peak_active {0}

std::atomic< uint64_t >	peak_queued {0}

std::atomic< uint64_t >	health_checks_performed {0}

std::atomic< uint64_t >	unhealthy_connections_removed {0}

Detailed Description

Performance metrics for connection pools.

Tracks key performance indicators for database connection management:

Connection acquisition latency
Queue wait times
Throughput rates
Priority-based statistics

Definition at line 25 of file pool_metrics.h.

Member Function Documentation

◆ average_wait_time_us()

double database::monitoring::pool_metrics::average_wait_time_us ( ) const

inline

Calculate average wait time.

Returns: Average wait time in microseconds

Definition at line 126 of file pool_metrics.h.

                                        {
        uint64_t total = total_acquisitions.load(std::memory_order_relaxed);
        if (total == 0) return 0.0;
 
        uint64_t total_wait = total_wait_time_us.load(std::memory_order_relaxed);
        return static_cast<double>(total_wait) / static_cast<double>(total);
    }

References total_acquisitions, and total_wait_time_us.

◆ record_acquisition()

void database::monitoring::pool_metrics::record_acquisition	(	uint64_t	wait_time_us,
		bool	success )

inline

Record a connection acquisition.

Parameters

wait_time_us	Wait time in microseconds
success	Whether acquisition was successful

Definition at line 52 of file pool_metrics.h.

                                                                 {
        total_acquisitions.fetch_add(1, std::memory_order_relaxed);
 
        if (success) {
            successful_acquisitions.fetch_add(1, std::memory_order_relaxed);
 
            // Update timing statistics
            total_wait_time_us.fetch_add(wait_time_us, std::memory_order_relaxed);
 
            // Update min/max (requires atomic compare-exchange)
            uint64_t current_min = min_wait_time_us.load(std::memory_order_relaxed);
            while (wait_time_us < current_min &&
                   !min_wait_time_us.compare_exchange_weak(current_min, wait_time_us,
                                                           std::memory_order_relaxed)) {}
 
            uint64_t current_max = max_wait_time_us.load(std::memory_order_relaxed);
            while (wait_time_us > current_max &&
                   !max_wait_time_us.compare_exchange_weak(current_max, wait_time_us,
                                                           std::memory_order_relaxed)) {}
        } else {
            failed_acquisitions.fetch_add(1, std::memory_order_relaxed);
        }
    }

References failed_acquisitions, max_wait_time_us, min_wait_time_us, database::success, successful_acquisitions, total_acquisitions, and total_wait_time_us.

◆ record_health_check()

void database::monitoring::pool_metrics::record_health_check ( uint64_t removed_connections = 0 )

inline

Record a health check operation.

Parameters

removed_connections Number of unhealthy connections removed

Definition at line 115 of file pool_metrics.h.

                                                               {
        health_checks_performed.fetch_add(1, std::memory_order_relaxed);
        if (removed_connections > 0) {
            unhealthy_connections_removed.fetch_add(removed_connections, std::memory_order_relaxed);
        }
    }

References health_checks_performed, and unhealthy_connections_removed.

◆ record_timeout()

void database::monitoring::pool_metrics::record_timeout ( )

inline

Record a timeout event.

Definition at line 79 of file pool_metrics.h.

                          {
        timeouts.fetch_add(1, std::memory_order_relaxed);
    }

References timeouts.

◆ reset()

void database::monitoring::pool_metrics::reset ( )

inline

Reset all metrics.

Definition at line 149 of file pool_metrics.h.

                 {
        total_acquisitions.store(0, std::memory_order_relaxed);
        successful_acquisitions.store(0, std::memory_order_relaxed);
        failed_acquisitions.store(0, std::memory_order_relaxed);
        timeouts.store(0, std::memory_order_relaxed);
 
        total_wait_time_us.store(0, std::memory_order_relaxed);
        min_wait_time_us.store(UINT64_MAX, std::memory_order_relaxed);
        max_wait_time_us.store(0, std::memory_order_relaxed);
 
        // Don't reset current_active and current_queued (they reflect current state)
        peak_active.store(current_active.load(std::memory_order_relaxed), std::memory_order_relaxed);
        peak_queued.store(current_queued.load(std::memory_order_relaxed), std::memory_order_relaxed);
 
        health_checks_performed.store(0, std::memory_order_relaxed);
        unhealthy_connections_removed.store(0, std::memory_order_relaxed);
    }

References current_active, current_queued, failed_acquisitions, health_checks_performed, max_wait_time_us, min_wait_time_us, peak_active, peak_queued, successful_acquisitions, timeouts, total_acquisitions, total_wait_time_us, and unhealthy_connections_removed.

◆ success_rate()

double database::monitoring::pool_metrics::success_rate ( ) const

inline

Calculate success rate.

Returns: Success rate as percentage (0.0 - 100.0)

Definition at line 138 of file pool_metrics.h.

                                {
        uint64_t total = total_acquisitions.load(std::memory_order_relaxed);
        if (total == 0) return 100.0;
 
        uint64_t successful = successful_acquisitions.load(std::memory_order_relaxed);
        return (static_cast<double>(successful) / static_cast<double>(total)) * 100.0;
    }

References successful_acquisitions, and total_acquisitions.

◆ update_active()

void database::monitoring::pool_metrics::update_active ( int delta )

inline

Update current active connection count.

Parameters

delta Change in active connections (+1 for acquire, -1 for release)

Definition at line 87 of file pool_metrics.h.

                                  {
        uint64_t new_active = current_active.fetch_add(delta, std::memory_order_relaxed) + delta;
 
        // Update peak if necessary
        uint64_t current_peak = peak_active.load(std::memory_order_relaxed);
        while (new_active > current_peak &&
               !peak_active.compare_exchange_weak(current_peak, new_active,
                                                  std::memory_order_relaxed)) {}
    }

References current_active, and peak_active.

◆ update_queued()

void database::monitoring::pool_metrics::update_queued ( int delta )

inline

Update current queued request count.

Parameters

delta Change in queued requests

Definition at line 101 of file pool_metrics.h.

                                  {
        uint64_t new_queued = current_queued.fetch_add(delta, std::memory_order_relaxed) + delta;
 
        // Update peak if necessary
        uint64_t current_peak = peak_queued.load(std::memory_order_relaxed);
        while (new_queued > current_peak &&
               !peak_queued.compare_exchange_weak(current_peak, new_queued,
                                                  std::memory_order_relaxed)) {}
    }

References current_queued, and peak_queued.

Member Data Documentation

◆ current_active

std::atomic<uint64_t> database::monitoring::pool_metrics::current_active {0}

Definition at line 38 of file pool_metrics.h.

38{0};

Referenced by reset(), and update_active().

◆ current_queued

std::atomic<uint64_t> database::monitoring::pool_metrics::current_queued {0}

Definition at line 39 of file pool_metrics.h.

39{0};

Referenced by reset(), and update_queued().

◆ failed_acquisitions

std::atomic<uint64_t> database::monitoring::pool_metrics::failed_acquisitions {0}

Definition at line 29 of file pool_metrics.h.

29{0};

Referenced by record_acquisition(), and reset().

◆ health_checks_performed

std::atomic<uint64_t> database::monitoring::pool_metrics::health_checks_performed {0}

Definition at line 44 of file pool_metrics.h.

44{0};

Referenced by record_health_check(), and reset().

◆ max_wait_time_us

std::atomic<uint64_t> database::monitoring::pool_metrics::max_wait_time_us {0}

Definition at line 35 of file pool_metrics.h.

35{0};

Referenced by record_acquisition(), and reset().

◆ min_wait_time_us

std::atomic<uint64_t> database::monitoring::pool_metrics::min_wait_time_us {UINT64_MAX}

Definition at line 34 of file pool_metrics.h.

34{UINT64_MAX};

Referenced by record_acquisition(), and reset().

◆ peak_active

std::atomic<uint64_t> database::monitoring::pool_metrics::peak_active {0}

Definition at line 40 of file pool_metrics.h.

40{0};

Referenced by reset(), and update_active().

◆ peak_queued

std::atomic<uint64_t> database::monitoring::pool_metrics::peak_queued {0}

Definition at line 41 of file pool_metrics.h.

41{0};

Referenced by reset(), and update_queued().

◆ successful_acquisitions

std::atomic<uint64_t> database::monitoring::pool_metrics::successful_acquisitions {0}

Definition at line 28 of file pool_metrics.h.

28{0};

Referenced by record_acquisition(), reset(), and success_rate().

◆ timeouts

std::atomic<uint64_t> database::monitoring::pool_metrics::timeouts {0}

Definition at line 30 of file pool_metrics.h.

30{0};

Referenced by record_timeout(), and reset().

◆ total_acquisitions

std::atomic<uint64_t> database::monitoring::pool_metrics::total_acquisitions {0}

Definition at line 27 of file pool_metrics.h.

27{0};

Referenced by average_wait_time_us(), record_acquisition(), reset(), and success_rate().

◆ total_wait_time_us

std::atomic<uint64_t> database::monitoring::pool_metrics::total_wait_time_us {0}

Definition at line 33 of file pool_metrics.h.

33{0};

Referenced by average_wait_time_us(), record_acquisition(), and reset().

◆ unhealthy_connections_removed

std::atomic<uint64_t> database::monitoring::pool_metrics::unhealthy_connections_removed {0}

Definition at line 45 of file pool_metrics.h.

45{0};

Referenced by record_health_check(), and reset().

The documentation for this struct was generated from the following file:

database/monitoring/pool_metrics.h

Public Member Functions

Public Attributes

Detailed Description

Member Function Documentation

◆ average_wait_time_us()

◆ record_acquisition()

◆ record_health_check()

◆ record_timeout()

◆ reset()

◆ success_rate()

◆ update_active()

◆ update_queued()

Member Data Documentation

◆ current_active

◆ current_queued

◆ failed_acquisitions

◆ health_checks_performed

◆ max_wait_time_us

◆ min_wait_time_us

◆ peak_active

◆ peak_queued

◆ successful_acquisitions

◆ timeouts

◆ total_acquisitions

◆ total_wait_time_us

◆ unhealthy_connections_removed