use std::sync::Arc;
use arc_swap::ArcSwap;
use opentelemetry::KeyValue;
use opentelemetry::metrics::ObservableGauge;
use crate::clients::ClientRegistry;
use crate::config::Config;
use crate::pool::{PoolManager, Routing};
use crate::topology::TopologyManager;
#[allow(dead_code)]
pub struct PoolGauges {
count: ObservableGauge<u64>,
max: ObservableGauge<u64>,
healthy: ObservableGauge<u64>,
clients: ObservableGauge<u64>,
queue_depth: ObservableGauge<u64>,
}
pub fn register_pool_gauges(
pools: &Arc<PoolManager>,
config: Arc<ArcSwap<Config>>,
topology: Arc<TopologyManager>,
clients: &Arc<ClientRegistry>,
) -> PoolGauges {
let meter = opentelemetry::global::meter("halephant");
let pools_for_count = Arc::clone(pools);
let count = meter
.u64_observable_gauge("db.client.connection.count")
.with_description("Number of connections in the pool")
.with_callback(move |observer| {
for (key, stats) in pools_for_count.pool_stats() {
let base = [
KeyValue::new("server.address", key.node),
KeyValue::new("db.namespace", key.database),
KeyValue::new("user", key.user),
];
let with_state = |state: &'static str, value: u32| {
let mut attrs = base.clone().to_vec();
attrs.push(KeyValue::new("state", state));
observer.observe(u64::from(value), &attrs);
};
with_state("active", stats.active);
with_state("idle", stats.idle);
with_state("resetting", stats.resetting);
}
})
.build();
let pools_for_max = Arc::clone(pools);
let max = meter
.u64_observable_gauge("db.client.connection.max")
.with_description("Configured maximum number of connections")
.with_callback(move |observer| {
for limits in pools_for_max.pool_limits() {
let db = KeyValue::new("db.namespace", limits.database);
if limits.max_primary > 0 {
observer.observe(
u64::from(limits.max_primary),
&[db.clone(), KeyValue::new("role", "primary")],
);
}
if limits.max_replica > 0 {
observer.observe(
u64::from(limits.max_replica),
&[db, KeyValue::new("role", "replica")],
);
}
}
})
.build();
let healthy = meter
.u64_observable_gauge("db.server.healthy")
.with_description("Whether an upstream node is reachable (1 = healthy, 0 = unreachable)")
.with_callback(move |observer| {
let cfg = config.load_full();
for (name, cluster) in &cfg.cluster {
let Some(topo) = topology.get(name) else {
continue;
};
for node in &cluster.nodes {
let healthy = !topo.unreachable.contains(node);
observer.observe(
u64::from(healthy),
&[
KeyValue::new("server.address", node.clone()),
KeyValue::new("cluster", name.clone()),
],
);
}
}
})
.build();
let clients_for_gauge = Arc::clone(clients);
let clients_gauge = meter
.u64_observable_gauge("halephant.client.connections")
.with_description("Number of client connections grouped by state")
.with_callback(move |observer| {
for (state, count) in clients_for_gauge.counts_by_state() {
observer.observe(count, &[KeyValue::new("state", state.as_str())]);
}
})
.build();
let pools_for_queue = Arc::clone(pools);
let queue_depth_gauge = meter
.u64_observable_gauge("halephant.client.queue_depth")
.with_description(
"Number of clients currently blocked waiting for pool capacity, \
grouped by (database, user, role)",
)
.with_callback(move |observer| {
for q in pools_for_queue.queue_stats() {
let role = match q.role {
Routing::Primary => "primary",
Routing::Replica => "replica",
};
observer.observe(
u64::from(q.depth),
&[
KeyValue::new("db.namespace", q.database),
KeyValue::new("user", q.user),
KeyValue::new("role", role),
],
);
}
})
.build();
PoolGauges {
count,
max,
healthy,
clients: clients_gauge,
queue_depth: queue_depth_gauge,
}
}