database::monitoring::performance_monitor Class Reference

Main performance monitoring system. More...

#include <performance_monitor.h>

Collaboration diagram for database::monitoring::performance_monitor:

Public Member Functions
	performance_monitor ()
	Constructor - now public for dependency injection.
	~performance_monitor ()
void	set_monitoring_enabled (bool enabled)
void	set_metrics_retention_period (std::chrono::minutes period)
void	set_alert_thresholds (double error_rate_threshold, std::chrono::microseconds latency_threshold)
void	record_query_metrics (const query_metrics &metrics)
void	record_connection_metrics (database_types db_type, const connection_metrics &metrics)
void	record_slow_query (const std::string &query, std::chrono::microseconds execution_time)
performance_summary	get_performance_summary () const
performance_summary	get_performance_summary (database_types db_type) const
std::vector< query_metrics >	get_recent_queries (std::chrono::minutes window) const
std::vector< query_metrics >	get_slow_queries (std::chrono::microseconds threshold) const
void	update_connection_count (database_types db_type, size_t active, size_t total)
connection_metrics	get_connection_metrics (database_types db_type) const
void	register_alert_handler (std::function< void(const performance_alert &)> handler)
std::vector< performance_alert >	get_recent_alerts (std::chrono::minutes window) const
void	clear_metrics ()
void	cleanup_old_metrics ()
std::string	get_metrics_json () const
std::string	get_dashboard_html () const

Private Member Functions
void	cleanup_thread ()
void	check_thresholds ()
void	emit_alert (performance_alert::alert_type type, const std::string &message)
std::string	calculate_query_hash (const std::string &query) const

Private Attributes
std::atomic< bool >	monitoring_enabled_ {true}
std::chrono::minutes	retention_period_ {60}
double	error_rate_threshold_ = 0.05
std::chrono::microseconds	latency_threshold_ {1000000}
std::mutex	metrics_mutex_
std::vector< query_metrics >	query_history_
std::unordered_map< database_types, connection_metrics >	connection_metrics_
std::vector< performance_alert >	alerts_
std::mutex	handlers_mutex_
std::vector< std::function< void(const performance_alert &)> >	alert_handlers_
std::atomic< bool >	cleanup_running_ {true}
std::thread	cleanup_thread_
std::condition_variable	cleanup_cv_
std::mutex	cleanup_mutex_
std::unordered_map< std::string, size_t >	query_patterns_
std::unordered_map< std::string, std::chrono::microseconds >	query_avg_times_

Detailed Description

Main performance monitoring system.

Definition at line 198 of file performance_monitor.h.

Constructor & Destructor Documentation

performance_monitor()

database::monitoring::performance_monitor::performance_monitor

(

)

Constructor - now public for dependency injection.

Since

Sprint 3 (Task 3.2)

Definition at line 57 of file performance_monitor.cpp.

    {
        // Disable background thread in sanitizer builds to avoid deadlocks
        // TSan/ASan/UBSan heavily instrument condition_variable operations causing extreme slowdowns
        // GCC defines __SANITIZE_THREAD__, __SANITIZE_ADDRESS__
        // Clang defines __has_feature(thread_sanitizer), __has_feature(address_sanitizer)
 
        // Check for sanitizers at compile time
        bool is_sanitizer_build = false;
#if defined(__SANITIZE_THREAD__) || defined(__SANITIZE_ADDRESS__)
        // GCC sanitizer detected
        is_sanitizer_build = true;
#endif
 
#ifdef __clang__
        // Clang-specific feature detection
#  if __has_feature(thread_sanitizer) || __has_feature(address_sanitizer) || __has_feature(undefined_behavior_sanitizer)
        is_sanitizer_build = true;
#  endif
#endif
 
        if (is_sanitizer_build) {
            // Sanitizer build detected - disable background thread
            cleanup_running_ = false;
            std::cout << "performance_monitor: background cleanup thread disabled (sanitizer build)" << std::endl;
        } else {
            // Normal build - start background cleanup thread
            cleanup_thread_ = std::thread(&performance_monitor::cleanup_thread, this);
        }
    }

References cleanup_running_, cleanup_thread(), and cleanup_thread_.

Here is the call graph for this function:

~performance_monitor()

database::monitoring::performance_monitor::~performance_monitor

(

)

Definition at line 88 of file performance_monitor.cpp.

    {
        cleanup_running_ = false;
        cleanup_cv_.notify_all();
        if (cleanup_thread_.joinable()) {
            cleanup_thread_.join();
        }
    }

References cleanup_cv_, cleanup_running_, and cleanup_thread_.

Member Function Documentation

calculate_query_hash()

std::string database::monitoring::performance_monitor::calculate_query_hash ( const std::string & query ) const

private

Definition at line 489 of file performance_monitor.cpp.

    {
        return std::to_string(std::hash<std::string>{}(query));
    }

check_thresholds()

void database::monitoring::performance_monitor::check_thresholds ( )

private

Definition at line 452 of file performance_monitor.cpp.

    {
        auto summary = get_performance_summary();
 
        // Check error rate threshold
        if (summary.error_rate > error_rate_threshold_) {
            emit_alert(performance_alert::alert_type::high_error_rate,
                      "High error rate: " + std::to_string(summary.error_rate * 100) + "%");
        }
 
        // Check latency threshold
        if (summary.avg_query_time > latency_threshold_) {
            emit_alert(performance_alert::alert_type::high_latency,
                      "High average latency: " + std::to_string(summary.avg_query_time.count()) + "μs");
        }
    }

References emit_alert(), error_rate_threshold_, get_performance_summary(), database::monitoring::performance_alert::high_error_rate, database::monitoring::performance_alert::high_latency, and latency_threshold_.

Referenced by cleanup_thread(), and record_query_metrics().

Here is the call graph for this function:

Here is the caller graph for this function:

cleanup_old_metrics()

void database::monitoring::performance_monitor::cleanup_old_metrics

(

)

Definition at line 388 of file performance_monitor.cpp.

    {
        std::lock_guard<std::mutex> lock(metrics_mutex_);
 
        auto cutoff = std::chrono::steady_clock::now() - retention_period_;
 
        // Remove old query metrics
        query_history_.erase(
            std::remove_if(query_history_.begin(), query_history_.end(),
                [cutoff](const query_metrics& m) {
                    return m.start_time < cutoff;
                }),
            query_history_.end());
 
        // Remove old alerts
        alerts_.erase(
            std::remove_if(alerts_.begin(), alerts_.end(),
                [cutoff](const performance_alert& alert) {
                    return alert.timestamp() < cutoff;
                }),
            alerts_.end());
    }

References alerts_, metrics_mutex_, query_history_, and retention_period_.

Referenced by cleanup_thread().

Here is the caller graph for this function:

cleanup_thread()

void database::monitoring::performance_monitor::cleanup_thread ( )

private

Definition at line 431 of file performance_monitor.cpp.

    {
        // Cleanup every 5 minutes, but check shutdown flag every second
        const auto cleanup_interval = std::chrono::minutes(5);
        auto last_cleanup = std::chrono::steady_clock::now();
 
        while (cleanup_running_) {
            std::unique_lock<std::mutex> lock(cleanup_mutex_);
            // Wait for 1 second or until notified to stop
            cleanup_cv_.wait_for(lock, std::chrono::seconds(1), [this] { return !cleanup_running_.load(); });
 
            // Perform cleanup every 5 minutes
            auto now = std::chrono::steady_clock::now();
            if (cleanup_running_ && (now - last_cleanup) >= cleanup_interval) {
                cleanup_old_metrics();
                check_thresholds();
                last_cleanup = now;
            }
        }
    }

References check_thresholds(), cleanup_cv_, cleanup_mutex_, cleanup_old_metrics(), and cleanup_running_.

Referenced by performance_monitor().

Here is the call graph for this function:

Here is the caller graph for this function:

clear_metrics()

void database::monitoring::performance_monitor::clear_metrics

(

)

Definition at line 378 of file performance_monitor.cpp.

    {
        std::lock_guard<std::mutex> lock(metrics_mutex_);
        query_history_.clear();
        connection_metrics_.clear();
        alerts_.clear();
        query_patterns_.clear();
        query_avg_times_.clear();
    }

References alerts_, connection_metrics_, metrics_mutex_, query_avg_times_, query_history_, and query_patterns_.

emit_alert()

void database::monitoring::performance_monitor::emit_alert ( performance_alert::alert_type type, const std::string & message )

private

Definition at line 469 of file performance_monitor.cpp.

    {
        performance_alert alert(type, message, std::chrono::steady_clock::now());
 
        {
            std::lock_guard<std::mutex> lock(metrics_mutex_);
            alerts_.push_back(alert);
        }
 
        // Notify alert handlers
        std::lock_guard<std::mutex> lock(handlers_mutex_);
        for (const auto& handler : alert_handlers_) {
            try {
                handler(alert);
            } catch (const std::exception& e) {
                std::cerr << "Alert handler exception: " << e.what() << std::endl;
            }
        }
    }

References alert_handlers_, alerts_, handlers_mutex_, and metrics_mutex_.

Referenced by check_thresholds(), record_connection_metrics(), record_query_metrics(), and record_slow_query().

Here is the caller graph for this function:

get_connection_metrics()

connection_metrics database::monitoring::performance_monitor::get_connection_metrics

(

database_types

db_type

)

const

Definition at line 339 of file performance_monitor.cpp.

    {
        std::lock_guard<std::mutex> lock(metrics_mutex_);
        auto it = connection_metrics_.find(db_type);
        if (it != connection_metrics_.end()) {
            connection_metrics result;
            result.total_connections.store(it->second.total_connections.load());
            result.active_connections.store(it->second.active_connections.load());
            result.idle_connections.store(it->second.idle_connections.load());
            result.failed_connections.store(it->second.failed_connections.load());
            result.avg_acquisition_time.store(it->second.avg_acquisition_time.load());
            result.max_acquisition_time.store(it->second.max_acquisition_time.load());
            result.last_update = it->second.last_update;
            return result;
        }
        return connection_metrics{};
    }

References database::monitoring::connection_metrics::active_connections, database::monitoring::connection_metrics::avg_acquisition_time, connection_metrics_, database::monitoring::connection_metrics::failed_connections, database::monitoring::connection_metrics::idle_connections, database::monitoring::connection_metrics::last_update, database::monitoring::connection_metrics::max_acquisition_time, metrics_mutex_, and database::monitoring::connection_metrics::total_connections.

get_dashboard_html()

std::string database::monitoring::performance_monitor::get_dashboard_html

(

)

const

get_metrics_json()

std::string database::monitoring::performance_monitor::get_metrics_json

(

)

const

Definition at line 411 of file performance_monitor.cpp.

    {
        auto summary = get_performance_summary();
 
        std::ostringstream json;
        json << "{\n";
        json << "  \"total_queries\": " << summary.total_queries << ",\n";
        json << "  \"successful_queries\": " << summary.successful_queries << ",\n";
        json << "  \"failed_queries\": " << summary.failed_queries << ",\n";
        json << "  \"avg_query_time_us\": " << summary.avg_query_time.count() << ",\n";
        json << "  \"queries_per_second\": " << summary.queries_per_second << ",\n";
        json << "  \"error_rate\": " << summary.error_rate << ",\n";
        json << "  \"total_connections\": " << summary.total_connections << ",\n";
        json << "  \"active_connections\": " << summary.active_connections << ",\n";
        json << "  \"connection_utilization\": " << summary.connection_utilization << "\n";
        json << "}";
 
        return json.str();
    }

References get_performance_summary().

Here is the call graph for this function:

get_performance_summary() [1/2]

performance_summary database::monitoring::performance_monitor::get_performance_summary

(

)

const

Definition at line 174 of file performance_monitor.cpp.

    {
        std::lock_guard<std::mutex> lock(metrics_mutex_);
 
        performance_summary summary;
        summary.measurement_start = std::chrono::steady_clock::now() - retention_period_;
        summary.measurement_end = std::chrono::steady_clock::now();
 
        if (query_history_.empty()) {
            return summary;
        }
 
        // Filter recent queries
        auto recent_start = summary.measurement_start;
        auto recent_queries = std::count_if(query_history_.begin(), query_history_.end(),
            [recent_start](const query_metrics& m) {
                return m.start_time >= recent_start;
            });
 
        summary.total_queries = recent_queries;
 
        // Calculate metrics from recent queries
        std::chrono::microseconds total_time{0};
        std::chrono::microseconds min_time{std::chrono::microseconds::max()};
        std::chrono::microseconds max_time{0};
        size_t successful = 0;
 
        for (const auto& metrics : query_history_) {
            if (metrics.start_time < recent_start) continue;
 
            total_time += metrics.execution_time;
            min_time = std::min(min_time, metrics.execution_time);
            max_time = std::max(max_time, metrics.execution_time);
 
            if (metrics.success) {
                successful++;
            } else {
                summary.error_counts[metrics.error_message]++;
            }
        }
 
        summary.successful_queries = successful;
        summary.failed_queries = summary.total_queries - successful;
 
        if (summary.total_queries > 0) {
            summary.avg_query_time = total_time / summary.total_queries;
            summary.min_query_time = min_time;
            summary.max_query_time = max_time;
            summary.error_rate = double(summary.failed_queries) / summary.total_queries;
        }
 
        // Calculate QPS
        auto duration_seconds = std::chrono::duration_cast<std::chrono::seconds>(
            summary.measurement_end - summary.measurement_start).count();
        if (duration_seconds > 0) {
            summary.queries_per_second = double(summary.total_queries) / duration_seconds;
        }
 
        // Connection metrics summary
        size_t total_connections = 0;
        size_t active_connections = 0;
        for (const auto& [db_type, conn_metrics] : connection_metrics_) {
            total_connections += conn_metrics.total_connections.load();
            active_connections += conn_metrics.active_connections.load();
        }
 
        summary.total_connections = total_connections;
        summary.active_connections = active_connections;
        if (total_connections > 0) {
            summary.connection_utilization = double(active_connections) / total_connections;
        }
 
        return summary;
    }

References database::monitoring::performance_summary::active_connections, database::monitoring::performance_summary::avg_query_time, connection_metrics_, database::monitoring::performance_summary::connection_utilization, database::monitoring::performance_summary::error_counts, database::monitoring::performance_summary::error_rate, database::monitoring::performance_summary::failed_queries, database::monitoring::performance_summary::max_query_time, database::monitoring::performance_summary::measurement_end, database::monitoring::performance_summary::measurement_start, metrics_mutex_, database::monitoring::performance_summary::min_query_time, database::monitoring::performance_summary::queries_per_second, query_history_, retention_period_, database::monitoring::performance_summary::successful_queries, database::monitoring::performance_summary::total_connections, and database::monitoring::performance_summary::total_queries.

Referenced by check_thresholds(), and get_metrics_json().

Here is the caller graph for this function:

get_performance_summary() [2/2]

performance_summary database::monitoring::performance_monitor::get_performance_summary

(

database_types

db_type

)

const

Definition at line 249 of file performance_monitor.cpp.

    {
        std::lock_guard<std::mutex> lock(metrics_mutex_);
 
        performance_summary summary;
        summary.measurement_start = std::chrono::steady_clock::now() - retention_period_;
        summary.measurement_end = std::chrono::steady_clock::now();
 
        // Filter by database type and time
        auto recent_start = summary.measurement_start;
        auto db_queries = std::count_if(query_history_.begin(), query_history_.end(),
            [recent_start, db_type](const query_metrics& m) {
                return m.start_time >= recent_start && m.db_type == db_type;
            });
 
        summary.total_queries = db_queries;
 
        // Calculate metrics for specific database type
        std::chrono::microseconds total_time{0};
        size_t successful = 0;
 
        for (const auto& metrics : query_history_) {
            if (metrics.start_time < recent_start || metrics.db_type != db_type) continue;
 
            total_time += metrics.execution_time;
            if (metrics.success) {
                successful++;
            }
        }
 
        summary.successful_queries = successful;
        summary.failed_queries = summary.total_queries - successful;
 
        if (summary.total_queries > 0) {
            summary.avg_query_time = total_time / summary.total_queries;
            summary.error_rate = double(summary.failed_queries) / summary.total_queries;
        }
 
        // Connection metrics for specific database
        auto it = connection_metrics_.find(db_type);
        if (it != connection_metrics_.end()) {
            summary.total_connections = it->second.total_connections.load();
            summary.active_connections = it->second.active_connections.load();
            if (summary.total_connections > 0) {
                summary.connection_utilization = double(summary.active_connections) / summary.total_connections;
            }
        }
 
        return summary;
    }

References database::monitoring::performance_summary::active_connections, database::monitoring::performance_summary::avg_query_time, connection_metrics_, database::monitoring::performance_summary::connection_utilization, database::monitoring::performance_summary::error_rate, database::monitoring::performance_summary::failed_queries, database::monitoring::performance_summary::measurement_end, database::monitoring::performance_summary::measurement_start, metrics_mutex_, query_history_, retention_period_, database::monitoring::performance_summary::successful_queries, database::monitoring::performance_summary::total_connections, and database::monitoring::performance_summary::total_queries.

get_recent_alerts()

std::vector< performance_alert > database::monitoring::performance_monitor::get_recent_alerts

(

std::chrono::minutes

window

)

const

Definition at line 363 of file performance_monitor.cpp.

    {
        std::lock_guard<std::mutex> lock(metrics_mutex_);
 
        auto cutoff = std::chrono::steady_clock::now() - window;
        std::vector<performance_alert> recent;
 
        std::copy_if(alerts_.begin(), alerts_.end(), std::back_inserter(recent),
            [cutoff](const performance_alert& alert) {
                return alert.timestamp() >= cutoff;
            });
 
        return recent;
    }

References alerts_, and metrics_mutex_.

get_recent_queries()

std::vector< query_metrics > database::monitoring::performance_monitor::get_recent_queries

(

std::chrono::minutes

window

)

const

Definition at line 300 of file performance_monitor.cpp.

    {
        std::lock_guard<std::mutex> lock(metrics_mutex_);
 
        auto cutoff = std::chrono::steady_clock::now() - window;
        std::vector<query_metrics> recent;
 
        std::copy_if(query_history_.begin(), query_history_.end(), std::back_inserter(recent),
            [cutoff](const query_metrics& m) {
                return m.start_time >= cutoff;
            });
 
        return recent;
    }

References metrics_mutex_, and query_history_.

get_slow_queries()

std::vector< query_metrics > database::monitoring::performance_monitor::get_slow_queries

(

std::chrono::microseconds

threshold

)

const

Definition at line 315 of file performance_monitor.cpp.

    {
        std::lock_guard<std::mutex> lock(metrics_mutex_);
 
        std::vector<query_metrics> slow_queries;
        std::copy_if(query_history_.begin(), query_history_.end(), std::back_inserter(slow_queries),
            [threshold](const query_metrics& m) {
                return m.execution_time >= threshold;
            });
 
        return slow_queries;
    }

References metrics_mutex_, and query_history_.

record_connection_metrics()

void database::monitoring::performance_monitor::record_connection_metrics	(	database_types	db_type,
		const connection_metrics &	metrics )

Definition at line 135 of file performance_monitor.cpp.

    {
        if (!monitoring_enabled_) return;
 
        bool pool_exhaustion = false;
        size_t active = 0;
        size_t total = 0;
        {
            std::lock_guard<std::mutex> lock(metrics_mutex_);
            auto& stored_metrics = connection_metrics_[db_type];
            stored_metrics.total_connections.store(metrics.total_connections.load());
            stored_metrics.active_connections.store(metrics.active_connections.load());
            stored_metrics.idle_connections.store(metrics.idle_connections.load());
            stored_metrics.failed_connections.store(metrics.failed_connections.load());
            stored_metrics.avg_acquisition_time.store(metrics.avg_acquisition_time.load());
            stored_metrics.max_acquisition_time.store(metrics.max_acquisition_time.load());
            stored_metrics.last_update = metrics.last_update;
 
            // Check for connection pool exhaustion (evaluate under lock, act outside)
            total = metrics.total_connections.load();
            active = metrics.active_connections.load();
            pool_exhaustion = (total > 0 && (double(active) / total) > 0.9);
        }
 
        if (pool_exhaustion) {
            emit_alert(performance_alert::alert_type::connection_pool_exhaustion,
                      "Connection pool utilization high: " + std::to_string(active) + "/" + std::to_string(total));
        }
    }

References database::monitoring::connection_metrics::active_connections, database::monitoring::connection_metrics::avg_acquisition_time, connection_metrics_, database::monitoring::performance_alert::connection_pool_exhaustion, emit_alert(), database::monitoring::connection_metrics::failed_connections, database::monitoring::connection_metrics::idle_connections, database::monitoring::connection_metrics::last_update, database::monitoring::connection_metrics::max_acquisition_time, metrics_mutex_, monitoring_enabled_, and database::monitoring::connection_metrics::total_connections.

Here is the call graph for this function:

record_query_metrics()

void database::monitoring::performance_monitor::record_query_metrics

(

const query_metrics &

metrics

)

Definition at line 104 of file performance_monitor.cpp.

    {
        if (!monitoring_enabled_) return;
 
        bool slow_query = false;
        {
            std::lock_guard<std::mutex> lock(metrics_mutex_);
            query_history_.push_back(metrics);
 
            // Update query patterns
            query_patterns_[metrics.query_hash]++;
 
            auto& avg_time = query_avg_times_[metrics.query_hash];
            auto count = query_patterns_[metrics.query_hash];
            avg_time = std::chrono::microseconds(
                (avg_time.count() * (count - 1) + metrics.execution_time.count()) / count);
 
            // Check for slow queries (evaluate under lock, act outside)
            slow_query = (metrics.execution_time > latency_threshold_);
        }
 
        // emit_alert and check_thresholds acquire metrics_mutex_ internally,
        // so they must be called outside the lock scope to avoid deadlock
        if (slow_query) {
            emit_alert(performance_alert::alert_type::slow_query,
                      "Slow query detected: " + std::to_string(metrics.execution_time.count()) + "μs");
        }
 
        check_thresholds();
    }

References check_thresholds(), emit_alert(), database::monitoring::query_metrics::execution_time, latency_threshold_, metrics_mutex_, monitoring_enabled_, query_avg_times_, database::monitoring::query_metrics::query_hash, query_history_, query_patterns_, and database::monitoring::performance_alert::slow_query.

Here is the call graph for this function:

record_slow_query()

void database::monitoring::performance_monitor::record_slow_query	(	const std::string &	query,
		std::chrono::microseconds	execution_time )

Definition at line 165 of file performance_monitor.cpp.

    {
        if (!monitoring_enabled_) return;
 
        emit_alert(performance_alert::alert_type::slow_query,
                  "Slow query: " + query.substr(0, 100) + "... (" +
                  std::to_string(execution_time.count()) + "μs)");
    }

References emit_alert(), monitoring_enabled_, and database::monitoring::performance_alert::slow_query.

Here is the call graph for this function:

register_alert_handler()

void database::monitoring::performance_monitor::register_alert_handler

(

std::function< void(const performance_alert &)>

handler

)

Definition at line 357 of file performance_monitor.cpp.

    {
        std::lock_guard<std::mutex> lock(handlers_mutex_);
        alert_handlers_.push_back(handler);
    }

References alert_handlers_, and handlers_mutex_.

set_alert_thresholds()

void database::monitoring::performance_monitor::set_alert_thresholds	(	double	error_rate_threshold,
		std::chrono::microseconds	latency_threshold )

Definition at line 97 of file performance_monitor.cpp.

    {
        error_rate_threshold_ = error_rate_threshold;
        latency_threshold_ = latency_threshold;
    }

References error_rate_threshold_, and latency_threshold_.

set_metrics_retention_period()

void database::monitoring::performance_monitor::set_metrics_retention_period ( std::chrono::minutes period )

inline

Definition at line 212 of file performance_monitor.h.

{ retention_period_ = period; }

References retention_period_.

set_monitoring_enabled()

void database::monitoring::performance_monitor::set_monitoring_enabled ( bool enabled )

inline

Definition at line 211 of file performance_monitor.h.

{ monitoring_enabled_ = enabled; }

References monitoring_enabled_.

update_connection_count()

void database::monitoring::performance_monitor::update_connection_count	(	database_types	db_type,
		size_t	active,
		size_t	total )

Definition at line 328 of file performance_monitor.cpp.

    {
        if (!monitoring_enabled_) return;
 
        std::lock_guard<std::mutex> lock(metrics_mutex_);
        auto& metrics = connection_metrics_[db_type];
        metrics.active_connections = active;
        metrics.total_connections = total;
        metrics.last_update = std::chrono::steady_clock::now();
    }

References connection_metrics_, metrics_mutex_, and monitoring_enabled_.

Member Data Documentation

alert_handlers_

std::vector<std::function<void(const performance_alert&)> > database::monitoring::performance_monitor::alert_handlers_

private

Definition at line 264 of file performance_monitor.h.

Referenced by emit_alert(), and register_alert_handler().

alerts_

std::vector<performance_alert> database::monitoring::performance_monitor::alerts_

private

Definition at line 260 of file performance_monitor.h.

Referenced by cleanup_old_metrics(), clear_metrics(), emit_alert(), and get_recent_alerts().

cleanup_cv_

std::condition_variable database::monitoring::performance_monitor::cleanup_cv_

private

Definition at line 269 of file performance_monitor.h.

Referenced by cleanup_thread(), and ~performance_monitor().

cleanup_mutex_

std::mutex database::monitoring::performance_monitor::cleanup_mutex_

private

Definition at line 270 of file performance_monitor.h.

Referenced by cleanup_thread().

cleanup_running_

std::atomic<bool> database::monitoring::performance_monitor::cleanup_running_ {true}

private

Definition at line 267 of file performance_monitor.h.

{true};

Referenced by cleanup_thread(), performance_monitor(), and ~performance_monitor().

cleanup_thread_

std::thread database::monitoring::performance_monitor::cleanup_thread_

private

Definition at line 268 of file performance_monitor.h.

Referenced by performance_monitor(), and ~performance_monitor().

connection_metrics_

std::unordered_map<database_types, connection_metrics> database::monitoring::performance_monitor::connection_metrics_

private

Definition at line 259 of file performance_monitor.h.

Referenced by clear_metrics(), get_connection_metrics(), get_performance_summary(), get_performance_summary(), record_connection_metrics(), and update_connection_count().

error_rate_threshold_

double database::monitoring::performance_monitor::error_rate_threshold_ = 0.05

private

Definition at line 253 of file performance_monitor.h.

Referenced by check_thresholds(), and set_alert_thresholds().

handlers_mutex_

std::mutex database::monitoring::performance_monitor::handlers_mutex_

private

Definition at line 263 of file performance_monitor.h.

Referenced by emit_alert(), and register_alert_handler().

latency_threshold_

std::chrono::microseconds database::monitoring::performance_monitor::latency_threshold_ {1000000}

private

Definition at line 254 of file performance_monitor.h.

{1000000}; // 1 second

Referenced by check_thresholds(), record_query_metrics(), and set_alert_thresholds().

metrics_mutex_

std::mutex database::monitoring::performance_monitor::metrics_mutex_

mutableprivate

Definition at line 257 of file performance_monitor.h.

Referenced by cleanup_old_metrics(), clear_metrics(), emit_alert(), get_connection_metrics(), get_performance_summary(), get_performance_summary(), get_recent_alerts(), get_recent_queries(), get_slow_queries(), record_connection_metrics(), record_query_metrics(), and update_connection_count().

monitoring_enabled_

std::atomic<bool> database::monitoring::performance_monitor::monitoring_enabled_ {true}

private

Definition at line 251 of file performance_monitor.h.

{true};

Referenced by record_connection_metrics(), record_query_metrics(), record_slow_query(), set_monitoring_enabled(), and update_connection_count().

query_avg_times_

std::unordered_map<std::string, std::chrono::microseconds> database::monitoring::performance_monitor::query_avg_times_

private

Definition at line 274 of file performance_monitor.h.

Referenced by clear_metrics(), and record_query_metrics().

query_history_

std::vector<query_metrics> database::monitoring::performance_monitor::query_history_

private

Definition at line 258 of file performance_monitor.h.

Referenced by cleanup_old_metrics(), clear_metrics(), get_performance_summary(), get_performance_summary(), get_recent_queries(), get_slow_queries(), and record_query_metrics().

query_patterns_

std::unordered_map<std::string, size_t> database::monitoring::performance_monitor::query_patterns_

private

Definition at line 273 of file performance_monitor.h.

Referenced by clear_metrics(), and record_query_metrics().

retention_period_

std::chrono::minutes database::monitoring::performance_monitor::retention_period_ {60}

private

Definition at line 252 of file performance_monitor.h.

{60}; // 1 hour

Referenced by cleanup_old_metrics(), get_performance_summary(), get_performance_summary(), and set_metrics_retention_period().

---

The documentation for this class was generated from the following files:

• database/monitoring/performance_monitor.h
• database/monitoring/performance_monitor.cpp