#include <gtest/gtest.h>
#include <chrono>
#include <string>
#include <vector>
#include <atomic>
#include <thread>
#include "database/monitoring/performance_monitor.h"
#include "database/monitoring/pool_metrics.h"

Include dependency graph for test_performance_monitor.cpp:

Classes
class	PerformanceMonitorQueryTest

class	MonitoringEnabledTest

class	FilteredSummaryTest

class	QueryHistoryTest

class	AlertSystemTest

class	MetricLifecycleTest

class	ConnectionMetricsTest

class	MetricsOutputTest

class	PerformanceAlertTest

class	PoolMetricsTest

class	PrometheusExporterTest

class	QueryTimerTest

Functions
static query_metrics	make_query (const std::string &hash, std::chrono::microseconds exec_time, bool success, database_types db_type=database_types::postgres, const std::string &error_msg="")

	TEST_F (PerformanceMonitorQueryTest, RecordAndRetrieveSingleQuery)

	TEST_F (PerformanceMonitorQueryTest, RecordMultipleQueries)

	TEST_F (PerformanceMonitorQueryTest, AvgQueryTimeCalculation)

	TEST_F (MonitoringEnabledTest, DisabledDoesNotRecordQueryMetrics)

	TEST_F (MonitoringEnabledTest, DisabledDoesNotRecordConnectionMetrics)

	TEST_F (MonitoringEnabledTest, DisabledDoesNotUpdateConnectionCount)

	TEST_F (MonitoringEnabledTest, ReEnableResumesRecording)

	TEST_F (FilteredSummaryTest, PostgresSummaryFiltersCorrectly)

	TEST_F (FilteredSummaryTest, SqliteSummaryFiltersCorrectly)

	TEST_F (FilteredSummaryTest, UnusedDbTypeReturnsZero)

	TEST_F (FilteredSummaryTest, OverallSummaryIncludesAll)

	TEST_F (QueryHistoryTest, GetRecentQueriesWithinWindow)

	TEST_F (QueryHistoryTest, GetRecentQueriesEmptyWindow)

	TEST_F (QueryHistoryTest, GetSlowQueriesAboveThreshold)

	TEST_F (QueryHistoryTest, GetSlowQueriesNoneAboveThreshold)

	TEST_F (QueryHistoryTest, GetSlowQueriesPreservesMetadata)

	TEST_F (AlertSystemTest, SlowQueryTriggersAlert)

	TEST_F (AlertSystemTest, RegisterAlertHandlerReceivesCallback)

	TEST_F (AlertSystemTest, MultipleHandlersAllCalled)

	TEST_F (AlertSystemTest, GetRecentAlertsEmptyByDefault)

	TEST_F (AlertSystemTest, RecordSlowQueryEmitsAlert)

	TEST_F (AlertSystemTest, ConnectionPoolExhaustionAlert)

	TEST_F (MetricLifecycleTest, ClearMetricsRemovesEverything)

	TEST_F (MetricLifecycleTest, CleanupOldMetricsRemovesExpired)

	TEST_F (MetricLifecycleTest, CleanupKeepsRecentMetrics)

	TEST_F (ConnectionMetricsTest, UpdateConnectionCountStoresValues)

	TEST_F (ConnectionMetricsTest, GetConnectionMetricsUnknownDbType)

	TEST_F (ConnectionMetricsTest, ConnectionSummaryIncludesMultipleTypes)

	TEST_F (MetricsOutputTest, GetMetricsJsonContainsFields)

	TEST_F (MetricsOutputTest, GetMetricsJsonEmptyMonitor)

	TEST_F (PerformanceAlertTest, ConstructionAndAccessors)

	TEST_F (PerformanceAlertTest, AllAlertTypes)

	TEST_F (PoolMetricsTest, InitialStateIsZero)

	TEST_F (PoolMetricsTest, RecordSuccessfulAcquisition)

	TEST_F (PoolMetricsTest, RecordFailedAcquisition)

	TEST_F (PoolMetricsTest, RecordMultipleAcquisitionsTracksMinMax)

	TEST_F (PoolMetricsTest, RecordTimeout)

	TEST_F (PoolMetricsTest, UpdateActiveTracksPeak)

	TEST_F (PoolMetricsTest, UpdateQueuedTracksPeak)

	TEST_F (PoolMetricsTest, RecordHealthCheck)

	TEST_F (PoolMetricsTest, AverageWaitTime)

	TEST_F (PoolMetricsTest, AverageWaitTimeZeroWhenNoAcquisitions)

	TEST_F (PoolMetricsTest, SuccessRate)

	TEST_F (PoolMetricsTest, SuccessRateNoAcquisitions)

	TEST_F (PoolMetricsTest, ResetClearsStatistics)

	TEST_F (PrometheusExporterTest, FormatContainsMetricNames)

	TEST_F (PrometheusExporterTest, ExportMetricsReturnsTrue)

	TEST_F (PrometheusExporterTest, ExportAlertsReturnsTrue)

	TEST_F (QueryTimerTest, DestructorRecordsMetrics)

	TEST_F (QueryTimerTest, SetErrorMarksFailure)

	TEST_F (QueryTimerTest, SetRowsAffected)

Function Documentation

◆ make_query()

static query_metrics make_query	(	const std::string &	hash,
		std::chrono::microseconds	exec_time,
		bool	success,
		database_types	db_type = database_types::postgres,
		const std::string &	error_msg = "" )

static

Definition at line 27 of file test_performance_monitor.cpp.

{
    query_metrics m;
    m.query_hash = hash;
    m.start_time = std::chrono::steady_clock::now();
    m.end_time = m.start_time + exec_time;
    m.execution_time = exec_time;
    m.success = success;
    m.error_message = error_msg;
    m.db_type = db_type;
    m.rows_affected = success ? 1 : 0;
    return m;
}

References database::monitoring::query_metrics::db_type, database::monitoring::query_metrics::end_time, database::monitoring::query_metrics::error_message, database::monitoring::query_metrics::execution_time, database::monitoring::query_metrics::query_hash, database::monitoring::query_metrics::rows_affected, database::monitoring::query_metrics::start_time, database::success, and database::monitoring::query_metrics::success.

Referenced by FilteredSummaryTest::SetUp(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), and TEST_F().

Here is the caller graph for this function:

◆ TEST_F() [1/51]

TEST_F	(	AlertSystemTest	,
		ConnectionPoolExhaustionAlert	)

Definition at line 346 of file test_performance_monitor.cpp.

                                                       {
    connection_metrics cm;
    cm.total_connections.store(10);
    cm.active_connections.store(10); // 100% utilization > 90% threshold
 
    monitor_->record_connection_metrics(database_types::postgres, cm);
 
    auto alerts = monitor_->get_recent_alerts(std::chrono::minutes(5));
    bool found_pool_alert = false;
    for (const auto& alert : alerts) {
        if (alert.type() == performance_alert::alert_type::connection_pool_exhaustion) {
            found_pool_alert = true;
        }
    }
    EXPECT_TRUE(found_pool_alert);
}

References database::monitoring::connection_metrics::active_connections, and database::monitoring::connection_metrics::total_connections.

◆ TEST_F() [2/51]

TEST_F	(	AlertSystemTest	,
		GetRecentAlertsEmptyByDefault	)

Definition at line 332 of file test_performance_monitor.cpp.

                                                       {
    auto alerts = monitor_->get_recent_alerts(std::chrono::minutes(5));
    EXPECT_TRUE(alerts.empty());
}

◆ TEST_F() [3/51]

TEST_F	(	AlertSystemTest	,
		MultipleHandlersAllCalled	)

Definition at line 313 of file test_performance_monitor.cpp.

                                                   {
    std::atomic<int> handler1_count{0};
    std::atomic<int> handler2_count{0};
 
    monitor_->register_alert_handler([&handler1_count](const performance_alert&) {
        handler1_count.fetch_add(1);
    });
    monitor_->register_alert_handler([&handler2_count](const performance_alert&) {
        handler2_count.fetch_add(1);
    });
 
    monitor_->set_alert_thresholds(0.05, std::chrono::microseconds(10));
    monitor_->record_query_metrics(
        make_query("slow", std::chrono::microseconds(1000), true));
 
    EXPECT_GE(handler1_count.load(), 1);
    EXPECT_GE(handler2_count.load(), 1);
}

References make_query().

Here is the call graph for this function:

◆ TEST_F() [4/51]

TEST_F	(	AlertSystemTest	,
		RecordSlowQueryEmitsAlert	)

Definition at line 337 of file test_performance_monitor.cpp.

                                                   {
    monitor_->record_slow_query("SELECT * FROM huge_table",
        std::chrono::microseconds(5000000));
 
    auto alerts = monitor_->get_recent_alerts(std::chrono::minutes(5));
    ASSERT_GE(alerts.size(), 1u);
    EXPECT_EQ(alerts.back().type(), performance_alert::alert_type::slow_query);
}

◆ TEST_F() [5/51]

TEST_F	(	AlertSystemTest	,
		RegisterAlertHandlerReceivesCallback	)

Definition at line 299 of file test_performance_monitor.cpp.

                                                              {
    std::atomic<int> callback_count{0};
    monitor_->register_alert_handler([&callback_count](const performance_alert&) {
        callback_count.fetch_add(1);
    });
 
    // Trigger alert via slow query
    monitor_->set_alert_thresholds(0.05, std::chrono::microseconds(10));
    monitor_->record_query_metrics(
        make_query("slow", std::chrono::microseconds(1000), true));
 
    EXPECT_GE(callback_count.load(), 1);
}

References make_query().

Here is the call graph for this function:

◆ TEST_F() [6/51]

TEST_F	(	AlertSystemTest	,
		SlowQueryTriggersAlert	)

Definition at line 279 of file test_performance_monitor.cpp.

                                                {
    // Set low latency threshold so our query triggers an alert
    monitor_->set_alert_thresholds(0.05, std::chrono::microseconds(100));
 
    monitor_->record_query_metrics(
        make_query("slow", std::chrono::microseconds(500), true));
 
    auto alerts = monitor_->get_recent_alerts(std::chrono::minutes(5));
    ASSERT_GE(alerts.size(), 1u);
 
    bool found_slow_query_alert = false;
    for (const auto& alert : alerts) {
        if (alert.type() == performance_alert::alert_type::slow_query) {
            found_slow_query_alert = true;
            EXPECT_FALSE(alert.message().empty());
        }
    }
    EXPECT_TRUE(found_slow_query_alert);
}

References make_query().

Here is the call graph for this function:

◆ TEST_F() [7/51]

TEST_F	(	ConnectionMetricsTest	,
		ConnectionSummaryIncludesMultipleTypes	)

Definition at line 444 of file test_performance_monitor.cpp.

                                                                      {
    // get_performance_summary() requires at least one query in history
    // to reach connection metrics aggregation (early return if empty)
    monitor_->record_query_metrics(
        make_query("q1", std::chrono::microseconds(100), true));
 
    monitor_->update_connection_count(database_types::postgres, 3, 10);
    monitor_->update_connection_count(database_types::sqlite, 2, 5);
 
    auto summary = monitor_->get_performance_summary();
    EXPECT_EQ(summary.total_connections, 15u);
    EXPECT_EQ(summary.active_connections, 5u);
    EXPECT_DOUBLE_EQ(summary.connection_utilization, 5.0 / 15.0);
}

References make_query().

Here is the call graph for this function:

◆ TEST_F() [8/51]

TEST_F	(	ConnectionMetricsTest	,
		GetConnectionMetricsUnknownDbType	)

Definition at line 438 of file test_performance_monitor.cpp.

                                                                 {
    auto cm = monitor_->get_connection_metrics(database_types::sqlite);
    EXPECT_EQ(cm.total_connections.load(), 0u);
    EXPECT_EQ(cm.active_connections.load(), 0u);
}

◆ TEST_F() [9/51]

TEST_F	(	ConnectionMetricsTest	,
		UpdateConnectionCountStoresValues	)

Definition at line 430 of file test_performance_monitor.cpp.

                                                                 {
    monitor_->update_connection_count(database_types::postgres, 5, 10);
 
    auto cm = monitor_->get_connection_metrics(database_types::postgres);
    EXPECT_EQ(cm.active_connections.load(), 5u);
    EXPECT_EQ(cm.total_connections.load(), 10u);
}

◆ TEST_F() [10/51]

TEST_F	(	FilteredSummaryTest	,
		OverallSummaryIncludesAll	)

Definition at line 193 of file test_performance_monitor.cpp.

                                                       {
    auto summary = monitor_->get_performance_summary();
    EXPECT_EQ(summary.total_queries, 4u);
}

◆ TEST_F() [11/51]

TEST_F	(	FilteredSummaryTest	,
		PostgresSummaryFiltersCorrectly	)

Definition at line 173 of file test_performance_monitor.cpp.

                                                             {
    auto summary = monitor_->get_performance_summary(database_types::postgres);
    EXPECT_EQ(summary.total_queries, 2u);
    EXPECT_EQ(summary.successful_queries, 2u);
    EXPECT_EQ(summary.failed_queries, 0u);
}

◆ TEST_F() [12/51]

TEST_F	(	FilteredSummaryTest	,
		SqliteSummaryFiltersCorrectly	)

Definition at line 180 of file test_performance_monitor.cpp.

                                                           {
    auto summary = monitor_->get_performance_summary(database_types::sqlite);
    EXPECT_EQ(summary.total_queries, 2u);
    EXPECT_EQ(summary.successful_queries, 1u);
    EXPECT_EQ(summary.failed_queries, 1u);
    EXPECT_DOUBLE_EQ(summary.error_rate, 0.5);
}

◆ TEST_F() [13/51]

TEST_F	(	FilteredSummaryTest	,
		UnusedDbTypeReturnsZero	)

Definition at line 188 of file test_performance_monitor.cpp.

                                                     {
    auto summary = monitor_->get_performance_summary(database_types::mongodb);
    EXPECT_EQ(summary.total_queries, 0u);
}

◆ TEST_F() [14/51]

TEST_F	(	MetricLifecycleTest	,
		CleanupKeepsRecentMetrics	)

Definition at line 405 of file test_performance_monitor.cpp.

                                                       {
    monitor_->set_metrics_retention_period(std::chrono::minutes(60));
 
    monitor_->record_query_metrics(
        make_query("recent", std::chrono::microseconds(100), true));
 
    monitor_->cleanup_old_metrics();
 
    auto summary = monitor_->get_performance_summary();
    EXPECT_EQ(summary.total_queries, 1u);
}

References make_query().

Here is the call graph for this function:

◆ TEST_F() [15/51]

TEST_F	(	MetricLifecycleTest	,
		CleanupOldMetricsRemovesExpired	)

Definition at line 392 of file test_performance_monitor.cpp.

                                                             {
    // Set very short retention period
    monitor_->set_metrics_retention_period(std::chrono::minutes(0));
 
    monitor_->record_query_metrics(
        make_query("old", std::chrono::microseconds(100), true));
 
    monitor_->cleanup_old_metrics();
 
    auto summary = monitor_->get_performance_summary();
    EXPECT_EQ(summary.total_queries, 0u);
}

References make_query().

Here is the call graph for this function:

◆ TEST_F() [16/51]

TEST_F	(	MetricLifecycleTest	,
		ClearMetricsRemovesEverything	)

Definition at line 376 of file test_performance_monitor.cpp.

                                                           {
    monitor_->record_query_metrics(
        make_query("q1", std::chrono::microseconds(100), true));
    monitor_->update_connection_count(database_types::postgres, 5, 10);
    monitor_->record_slow_query("SELECT 1", std::chrono::microseconds(999999));
 
    monitor_->clear_metrics();
 
    auto summary = monitor_->get_performance_summary();
    EXPECT_EQ(summary.total_queries, 0u);
    EXPECT_EQ(summary.total_connections, 0u);
 
    auto alerts = monitor_->get_recent_alerts(std::chrono::minutes(60));
    EXPECT_TRUE(alerts.empty());
}

References make_query().

Here is the call graph for this function:

◆ TEST_F() [17/51]

TEST_F	(	MetricsOutputTest	,
		GetMetricsJsonContainsFields	)

Definition at line 472 of file test_performance_monitor.cpp.

                                                        {
    monitor_->record_query_metrics(
        make_query("q1", std::chrono::microseconds(1000), true));
 
    std::string json = monitor_->get_metrics_json();
    EXPECT_NE(json.find("total_queries"), std::string::npos);
    EXPECT_NE(json.find("successful_queries"), std::string::npos);
    EXPECT_NE(json.find("failed_queries"), std::string::npos);
    EXPECT_NE(json.find("avg_query_time_us"), std::string::npos);
    EXPECT_NE(json.find("error_rate"), std::string::npos);
    EXPECT_NE(json.find("active_connections"), std::string::npos);
}

References make_query().

Here is the call graph for this function:

◆ TEST_F() [18/51]

TEST_F	(	MetricsOutputTest	,
		GetMetricsJsonEmptyMonitor	)

Definition at line 485 of file test_performance_monitor.cpp.

                                                      {
    std::string json = monitor_->get_metrics_json();
    EXPECT_FALSE(json.empty());
    EXPECT_NE(json.find("total_queries"), std::string::npos);
}

◆ TEST_F() [19/51]

TEST_F	(	MonitoringEnabledTest	,
		DisabledDoesNotRecordConnectionMetrics	)

Definition at line 117 of file test_performance_monitor.cpp.

                                                                      {
    monitor_->set_monitoring_enabled(false);
 
    connection_metrics cm;
    cm.total_connections.store(10);
    cm.active_connections.store(5);
    monitor_->record_connection_metrics(database_types::postgres, cm);
 
    auto retrieved = monitor_->get_connection_metrics(database_types::postgres);
    EXPECT_EQ(retrieved.total_connections.load(), 0u);
}

References database::monitoring::connection_metrics::active_connections, and database::monitoring::connection_metrics::total_connections.

◆ TEST_F() [20/51]

TEST_F	(	MonitoringEnabledTest	,
		DisabledDoesNotRecordQueryMetrics	)

Definition at line 108 of file test_performance_monitor.cpp.

                                                                 {
    monitor_->set_monitoring_enabled(false);
    monitor_->record_query_metrics(
        make_query("q1", std::chrono::microseconds(1000), true));
 
    auto summary = monitor_->get_performance_summary();
    EXPECT_EQ(summary.total_queries, 0u);
}

References make_query().

Here is the call graph for this function:

◆ TEST_F() [21/51]

TEST_F	(	MonitoringEnabledTest	,
		DisabledDoesNotUpdateConnectionCount	)

Definition at line 129 of file test_performance_monitor.cpp.

                                                                    {
    monitor_->set_monitoring_enabled(false);
    monitor_->update_connection_count(database_types::sqlite, 5, 10);
 
    auto retrieved = monitor_->get_connection_metrics(database_types::postgres);
    EXPECT_EQ(retrieved.total_connections.load(), 0u);
}

◆ TEST_F() [22/51]

TEST_F	(	MonitoringEnabledTest	,
		ReEnableResumesRecording	)

Definition at line 137 of file test_performance_monitor.cpp.

                                                        {
    monitor_->set_monitoring_enabled(false);
    monitor_->record_query_metrics(
        make_query("ignored", std::chrono::microseconds(100), true));
 
    monitor_->set_monitoring_enabled(true);
    monitor_->record_query_metrics(
        make_query("recorded", std::chrono::microseconds(200), true));
 
    auto summary = monitor_->get_performance_summary();
    EXPECT_EQ(summary.total_queries, 1u);
}

References make_query().

Here is the call graph for this function:

◆ TEST_F() [23/51]

TEST_F	(	PerformanceAlertTest	,
		AllAlertTypes	)

Definition at line 509 of file test_performance_monitor.cpp.

                                            {
    auto now = std::chrono::steady_clock::now();
    const performance_alert::alert_type types[] = {
        performance_alert::alert_type::high_latency,
        performance_alert::alert_type::high_error_rate,
        performance_alert::alert_type::connection_pool_exhaustion,
        performance_alert::alert_type::slow_query,
        performance_alert::alert_type::memory_usage,
        performance_alert::alert_type::cpu_usage
    };
 
    for (auto type : types) {
        performance_alert alert(type, "test", now);
        EXPECT_EQ(alert.type(), type);
    }
}

References database::monitoring::performance_alert::type().

Here is the call graph for this function:

◆ TEST_F() [24/51]

TEST_F	(	PerformanceAlertTest	,
		ConstructionAndAccessors	)

Definition at line 497 of file test_performance_monitor.cpp.

                                                       {
    auto now = std::chrono::steady_clock::now();
    performance_alert alert(
        performance_alert::alert_type::high_latency,
        "Latency too high",
        now);
 
    EXPECT_EQ(alert.type(), performance_alert::alert_type::high_latency);
    EXPECT_EQ(alert.message(), "Latency too high");
    EXPECT_EQ(alert.timestamp(), now);
}

References database::monitoring::performance_alert::message(), database::monitoring::performance_alert::timestamp(), and database::monitoring::performance_alert::type().

Here is the call graph for this function:

◆ TEST_F() [25/51]

TEST_F	(	PerformanceMonitorQueryTest	,
		AvgQueryTimeCalculation	)

Definition at line 85 of file test_performance_monitor.cpp.

                                                             {
    monitor_->record_query_metrics(
        make_query("q1", std::chrono::microseconds(1000), true));
    monitor_->record_query_metrics(
        make_query("q2", std::chrono::microseconds(3000), true));
 
    auto summary = monitor_->get_performance_summary();
    EXPECT_EQ(summary.avg_query_time.count(), 2000);
}

References make_query().

Here is the call graph for this function:

◆ TEST_F() [26/51]

TEST_F	(	PerformanceMonitorQueryTest	,
		RecordAndRetrieveSingleQuery	)

Definition at line 59 of file test_performance_monitor.cpp.

                                                                  {
    auto m = make_query("hash1", std::chrono::microseconds(5000), true);
    monitor_->record_query_metrics(m);
 
    auto summary = monitor_->get_performance_summary();
    EXPECT_EQ(summary.total_queries, 1u);
    EXPECT_EQ(summary.successful_queries, 1u);
    EXPECT_EQ(summary.failed_queries, 0u);
}

References make_query().

Here is the call graph for this function:

◆ TEST_F() [27/51]

TEST_F	(	PerformanceMonitorQueryTest	,
		RecordMultipleQueries	)

Definition at line 69 of file test_performance_monitor.cpp.

                                                           {
    monitor_->record_query_metrics(
        make_query("q1", std::chrono::microseconds(1000), true));
    monitor_->record_query_metrics(
        make_query("q2", std::chrono::microseconds(2000), true));
    monitor_->record_query_metrics(
        make_query("q3", std::chrono::microseconds(3000), false,
            database_types::postgres, "timeout"));
 
    auto summary = monitor_->get_performance_summary();
    EXPECT_EQ(summary.total_queries, 3u);
    EXPECT_EQ(summary.successful_queries, 2u);
    EXPECT_EQ(summary.failed_queries, 1u);
    EXPECT_GT(summary.error_rate, 0.0);
}

References make_query().

Here is the call graph for this function:

◆ TEST_F() [28/51]

TEST_F	(	PoolMetricsTest	,
		AverageWaitTime	)

Definition at line 612 of file test_performance_monitor.cpp.

                                         {
    metrics_.record_acquisition(100, true);
    metrics_.record_acquisition(300, true);
 
    // average_wait_time_us divides by total_acquisitions (2), not successful
    EXPECT_DOUBLE_EQ(metrics_.average_wait_time_us(), 200.0);
}

◆ TEST_F() [29/51]

TEST_F	(	PoolMetricsTest	,
		AverageWaitTimeZeroWhenNoAcquisitions	)

Definition at line 620 of file test_performance_monitor.cpp.

                                                               {
    EXPECT_DOUBLE_EQ(metrics_.average_wait_time_us(), 0.0);
}

◆ TEST_F() [30/51]

TEST_F	(	PoolMetricsTest	,
		InitialStateIsZero	)

Definition at line 535 of file test_performance_monitor.cpp.

                                            {
    EXPECT_EQ(metrics_.total_acquisitions.load(), 0u);
    EXPECT_EQ(metrics_.successful_acquisitions.load(), 0u);
    EXPECT_EQ(metrics_.failed_acquisitions.load(), 0u);
    EXPECT_EQ(metrics_.timeouts.load(), 0u);
    EXPECT_EQ(metrics_.current_active.load(), 0u);
    EXPECT_EQ(metrics_.current_queued.load(), 0u);
}

◆ TEST_F() [31/51]

TEST_F	(	PoolMetricsTest	,
		RecordFailedAcquisition	)

Definition at line 555 of file test_performance_monitor.cpp.

                                                 {
    metrics_.record_acquisition(0, false);
 
    EXPECT_EQ(metrics_.total_acquisitions.load(), 1u);
    EXPECT_EQ(metrics_.successful_acquisitions.load(), 0u);
    EXPECT_EQ(metrics_.failed_acquisitions.load(), 1u);
}

◆ TEST_F() [32/51]

TEST_F	(	PoolMetricsTest	,
		RecordHealthCheck	)

Definition at line 603 of file test_performance_monitor.cpp.

                                           {
    metrics_.record_health_check(0);
    metrics_.record_health_check(2);
    metrics_.record_health_check(1);
 
    EXPECT_EQ(metrics_.health_checks_performed.load(), 3u);
    EXPECT_EQ(metrics_.unhealthy_connections_removed.load(), 3u);
}

◆ TEST_F() [33/51]

TEST_F	(	PoolMetricsTest	,
		RecordMultipleAcquisitionsTracksMinMax	)

Definition at line 563 of file test_performance_monitor.cpp.

                                                                {
    metrics_.record_acquisition(100, true);
    metrics_.record_acquisition(500, true);
    metrics_.record_acquisition(200, true);
 
    EXPECT_EQ(metrics_.total_acquisitions.load(), 3u);
    EXPECT_EQ(metrics_.successful_acquisitions.load(), 3u);
    EXPECT_EQ(metrics_.total_wait_time_us.load(), 800u);
    EXPECT_EQ(metrics_.min_wait_time_us.load(), 100u);
    EXPECT_EQ(metrics_.max_wait_time_us.load(), 500u);
}

◆ TEST_F() [34/51]

TEST_F	(	PoolMetricsTest	,
		RecordSuccessfulAcquisition	)

Definition at line 544 of file test_performance_monitor.cpp.

                                                     {
    metrics_.record_acquisition(500, true);
 
    EXPECT_EQ(metrics_.total_acquisitions.load(), 1u);
    EXPECT_EQ(metrics_.successful_acquisitions.load(), 1u);
    EXPECT_EQ(metrics_.failed_acquisitions.load(), 0u);
    EXPECT_EQ(metrics_.total_wait_time_us.load(), 500u);
    EXPECT_EQ(metrics_.min_wait_time_us.load(), 500u);
    EXPECT_EQ(metrics_.max_wait_time_us.load(), 500u);
}

◆ TEST_F() [35/51]

TEST_F	(	PoolMetricsTest	,
		RecordTimeout	)

Definition at line 575 of file test_performance_monitor.cpp.

                                       {
    metrics_.record_timeout();
    metrics_.record_timeout();
 
    EXPECT_EQ(metrics_.timeouts.load(), 2u);
}

◆ TEST_F() [36/51]

TEST_F	(	PoolMetricsTest	,
		ResetClearsStatistics	)

Definition at line 636 of file test_performance_monitor.cpp.

                                               {
    metrics_.record_acquisition(500, true);
    metrics_.record_timeout();
    metrics_.update_active(3);
    metrics_.record_health_check(1);
 
    metrics_.reset();
 
    EXPECT_EQ(metrics_.total_acquisitions.load(), 0u);
    EXPECT_EQ(metrics_.successful_acquisitions.load(), 0u);
    EXPECT_EQ(metrics_.timeouts.load(), 0u);
    EXPECT_EQ(metrics_.total_wait_time_us.load(), 0u);
    EXPECT_EQ(metrics_.min_wait_time_us.load(), UINT64_MAX);
    EXPECT_EQ(metrics_.max_wait_time_us.load(), 0u);
    EXPECT_EQ(metrics_.health_checks_performed.load(), 0u);
    // current_active should remain (reflects current state)
    EXPECT_EQ(metrics_.current_active.load(), 3u);
    // peak_active reset to current_active
    EXPECT_EQ(metrics_.peak_active.load(), 3u);
}

◆ TEST_F() [37/51]

TEST_F	(	PoolMetricsTest	,
		SuccessRate	)

Definition at line 624 of file test_performance_monitor.cpp.

                                     {
    metrics_.record_acquisition(100, true);
    metrics_.record_acquisition(200, true);
    metrics_.record_acquisition(0, false);
 
    EXPECT_NEAR(metrics_.success_rate(), 66.666, 0.01);
}

◆ TEST_F() [38/51]

TEST_F	(	PoolMetricsTest	,
		SuccessRateNoAcquisitions	)

Definition at line 632 of file test_performance_monitor.cpp.

                                                   {
    EXPECT_DOUBLE_EQ(metrics_.success_rate(), 100.0);
}

◆ TEST_F() [39/51]

TEST_F	(	PoolMetricsTest	,
		UpdateActiveTracksPeak	)

Definition at line 582 of file test_performance_monitor.cpp.

                                                {
    metrics_.update_active(1);
    metrics_.update_active(1);
    metrics_.update_active(1); // peak = 3
    metrics_.update_active(-1); // current = 2
 
    EXPECT_EQ(metrics_.current_active.load(), 2u);
    EXPECT_EQ(metrics_.peak_active.load(), 3u);
}

◆ TEST_F() [40/51]

TEST_F	(	PoolMetricsTest	,
		UpdateQueuedTracksPeak	)

Definition at line 592 of file test_performance_monitor.cpp.

                                                {
    metrics_.update_queued(1);
    metrics_.update_queued(1);
    metrics_.update_queued(1); // peak = 3
    metrics_.update_queued(-1);
    metrics_.update_queued(-1); // current = 1
 
    EXPECT_EQ(metrics_.current_queued.load(), 1u);
    EXPECT_EQ(metrics_.peak_queued.load(), 3u);
}

◆ TEST_F() [41/51]

TEST_F	(	PrometheusExporterTest	,
		ExportAlertsReturnsTrue	)

Definition at line 685 of file test_performance_monitor.cpp.

                                                        {
    prometheus_exporter exporter("localhost", 9090);
    std::vector<performance_alert> alerts;
    alerts.emplace_back(
        performance_alert::alert_type::slow_query, "test",
        std::chrono::steady_clock::now());
 
    EXPECT_TRUE(exporter.export_alerts(alerts));
}

References database::monitoring::prometheus_exporter::export_alerts().

Here is the call graph for this function:

◆ TEST_F() [42/51]

TEST_F	(	PrometheusExporterTest	,
		ExportMetricsReturnsTrue	)

Definition at line 678 of file test_performance_monitor.cpp.

                                                         {
    prometheus_exporter exporter("localhost", 9090);
    performance_summary summary;
 
    EXPECT_TRUE(exporter.export_metrics(summary));
}

References database::monitoring::prometheus_exporter::export_metrics().

Here is the call graph for this function:

◆ TEST_F() [43/51]

TEST_F	(	PrometheusExporterTest	,
		FormatContainsMetricNames	)

Definition at line 663 of file test_performance_monitor.cpp.

                                                          {
    prometheus_exporter exporter("localhost", 9090);
    performance_summary summary;
    summary.total_queries = 100;
    summary.avg_query_time = std::chrono::microseconds(500);
    summary.error_rate = 0.02;
    summary.active_connections = 5;
 
    std::string output = exporter.format_prometheus_metrics(summary);
    EXPECT_NE(output.find("database_queries_total 100"), std::string::npos);
    EXPECT_NE(output.find("database_query_duration_microseconds 500"), std::string::npos);
    EXPECT_NE(output.find("database_error_rate 0.02"), std::string::npos);
    EXPECT_NE(output.find("database_connections_active 5"), std::string::npos);
}

References database::monitoring::performance_summary::active_connections, database::monitoring::performance_summary::avg_query_time, database::monitoring::performance_summary::error_rate, database::monitoring::prometheus_exporter::format_prometheus_metrics(), and database::monitoring::performance_summary::total_queries.

Here is the call graph for this function:

◆ TEST_F() [44/51]

TEST_F	(	QueryHistoryTest	,
		GetRecentQueriesEmptyWindow	)

Definition at line 221 of file test_performance_monitor.cpp.

                                                      {
    monitor_->record_query_metrics(
        make_query("q1", std::chrono::microseconds(100), true));
 
    // Use zero-length window — queries just recorded should still be within
    // the window since their start_time is "now"
    auto recent = monitor_->get_recent_queries(std::chrono::minutes(0));
    // With 0-minute window, cutoff == now, so queries at exactly now are borderline
    // Result depends on timing; we just verify no crash
    EXPECT_LE(recent.size(), 1u);
}

References make_query().

Here is the call graph for this function:

◆ TEST_F() [45/51]

TEST_F	(	QueryHistoryTest	,
		GetRecentQueriesWithinWindow	)

Definition at line 211 of file test_performance_monitor.cpp.

                                                       {
    monitor_->record_query_metrics(
        make_query("q1", std::chrono::microseconds(100), true));
    monitor_->record_query_metrics(
        make_query("q2", std::chrono::microseconds(200), true));
 
    auto recent = monitor_->get_recent_queries(std::chrono::minutes(5));
    EXPECT_EQ(recent.size(), 2u);
}

References make_query().

Here is the call graph for this function:

◆ TEST_F() [46/51]

TEST_F	(	QueryHistoryTest	,
		GetSlowQueriesAboveThreshold	)

Definition at line 233 of file test_performance_monitor.cpp.

                                                       {
    monitor_->record_query_metrics(
        make_query("fast", std::chrono::microseconds(100), true));
    monitor_->record_query_metrics(
        make_query("medium", std::chrono::microseconds(5000), true));
    monitor_->record_query_metrics(
        make_query("slow", std::chrono::microseconds(50000), true));
 
    auto slow = monitor_->get_slow_queries(std::chrono::microseconds(4000));
    EXPECT_EQ(slow.size(), 2u);
}

References make_query().

Here is the call graph for this function:

◆ TEST_F() [47/51]

TEST_F	(	QueryHistoryTest	,
		GetSlowQueriesNoneAboveThreshold	)

Definition at line 245 of file test_performance_monitor.cpp.

                                                           {
    monitor_->record_query_metrics(
        make_query("fast", std::chrono::microseconds(100), true));
 
    auto slow = monitor_->get_slow_queries(std::chrono::microseconds(1000000));
    EXPECT_TRUE(slow.empty());
}

References make_query().

Here is the call graph for this function:

◆ TEST_F() [48/51]

TEST_F	(	QueryHistoryTest	,
		GetSlowQueriesPreservesMetadata	)

Definition at line 253 of file test_performance_monitor.cpp.

                                                          {
    auto original = make_query("slow_hash", std::chrono::microseconds(99999), false,
        database_types::sqlite, "timeout");
    monitor_->record_query_metrics(original);
 
    auto slow = monitor_->get_slow_queries(std::chrono::microseconds(1000));
    ASSERT_EQ(slow.size(), 1u);
    EXPECT_EQ(slow[0].query_hash, "slow_hash");
    EXPECT_FALSE(slow[0].success);
    EXPECT_EQ(slow[0].error_message, "timeout");
    EXPECT_EQ(slow[0].db_type, database_types::sqlite);
}

References ASSERT_EQ, make_query(), and database::success.

Here is the call graph for this function:

◆ TEST_F() [49/51]

TEST_F	(	QueryTimerTest	,
		DestructorRecordsMetrics	)

Definition at line 708 of file test_performance_monitor.cpp.

                                                 {
    {
        query_timer timer("SELECT 1", database_types::postgres, monitor_);
        // Timer will record on destruction
    }
 
    auto summary = monitor_->get_performance_summary();
    EXPECT_EQ(summary.total_queries, 1u);
    EXPECT_EQ(summary.successful_queries, 1u);
}

◆ TEST_F() [50/51]

TEST_F	(	QueryTimerTest	,
		SetErrorMarksFailure	)

Definition at line 719 of file test_performance_monitor.cpp.

                                             {
    {
        query_timer timer("SELECT bad", database_types::postgres, monitor_);
        timer.set_error("syntax error");
    }
 
    auto summary = monitor_->get_performance_summary();
    EXPECT_EQ(summary.total_queries, 1u);
    EXPECT_EQ(summary.failed_queries, 1u);
}

References database::monitoring::query_timer::set_error().

Here is the call graph for this function:

◆ TEST_F() [51/51]

TEST_F	(	QueryTimerTest	,
		SetRowsAffected	)

Definition at line 730 of file test_performance_monitor.cpp.

                                        {
    {
        query_timer timer("INSERT INTO test VALUES (1)", database_types::sqlite, monitor_);
        timer.set_rows_affected(42);
    }
 
    auto recent = monitor_->get_recent_queries(std::chrono::minutes(5));
    ASSERT_EQ(recent.size(), 1u);
    EXPECT_EQ(recent[0].rows_affected, 42u);
}

References ASSERT_EQ, and database::monitoring::query_timer::set_rows_affected().

Here is the call graph for this function:

Classes

Functions

Function Documentation

◆ make_query()

◆ TEST_F() [1/51]

◆ TEST_F() [2/51]

◆ TEST_F() [3/51]

◆ TEST_F() [4/51]

◆ TEST_F() [5/51]

◆ TEST_F() [6/51]

◆ TEST_F() [7/51]

◆ TEST_F() [8/51]

◆ TEST_F() [9/51]

◆ TEST_F() [10/51]

◆ TEST_F() [11/51]

◆ TEST_F() [12/51]

◆ TEST_F() [13/51]

◆ TEST_F() [14/51]

◆ TEST_F() [15/51]

◆ TEST_F() [16/51]

◆ TEST_F() [17/51]

◆ TEST_F() [18/51]

◆ TEST_F() [19/51]

◆ TEST_F() [20/51]

◆ TEST_F() [21/51]

◆ TEST_F() [22/51]

◆ TEST_F() [23/51]

◆ TEST_F() [24/51]

◆ TEST_F() [25/51]

◆ TEST_F() [26/51]

◆ TEST_F() [27/51]

◆ TEST_F() [28/51]

◆ TEST_F() [29/51]

◆ TEST_F() [30/51]

◆ TEST_F() [31/51]

◆ TEST_F() [32/51]

◆ TEST_F() [33/51]

◆ TEST_F() [34/51]

◆ TEST_F() [35/51]

◆ TEST_F() [36/51]

◆ TEST_F() [37/51]

◆ TEST_F() [38/51]

◆ TEST_F() [39/51]

◆ TEST_F() [40/51]

◆ TEST_F() [41/51]

◆ TEST_F() [42/51]

◆ TEST_F() [43/51]

◆ TEST_F() [44/51]

◆ TEST_F() [45/51]

◆ TEST_F() [46/51]

◆ TEST_F() [47/51]

◆ TEST_F() [48/51]

◆ TEST_F() [49/51]

◆ TEST_F() [50/51]

◆ TEST_F() [51/51]