:hedgehog: PostHog is the leading platform for building self-driving products. Our developer tools – AI observability, analytics, session replay, flags, experiments, error tracking, logs, and more – capture all the context agents need to diagnose problems, uncover opportunities, and ship fixes. Steer it all from Slack, web, desktop, or the MCP.
Python ab-testingai-analyticsanalyticscdpdata-warehouseexperimentsfeature-flagsjavascriptproduct-analyticspythonreactsession-replaysurveystypescriptweb-analytics
//! `pg_stat_statements` deltas (Tier B). On Aurora, reads `aurora_stat_statements`
//! instead, which adds Aurora-storage I/O and per-query peak memory columns.
//!
//! What this cannot give you: per-call latency quantiles. pg_stat_statements has no
//! histogram; real p95/p99 come from sampled statement logs (phase 4,
//! `ts_query_durations`) keyed by the same `queryid`.
use super::statements::{self, Source};
use crate::collector::*;
use anyhow::Result;
use async_trait::async_trait;
use std::time::Duration;
pub struct QueryStats;
const KEY: &[&str] = &["queryid", "datname", "rolname", "toplevel"];
#[async_trait]
impl Collector for QueryStats {
fn name(&self) -> &str {
"query_stats"
}
fn interval(&self) -> Duration {
Duration::from_secs(60)
}
fn scope(&self) -> Scope {
Scope::Cluster
}
fn kind(&self) -> Kind {
Kind::Cumulative
}
fn min_pg_version(&self) -> u32 {
130000
}
async fn collect(
&self,
cx: &CollectCtx<'_>,
prev: Option<&State>,
) -> Result<(Snapshot, State)> {
let mut extra = statements::load_extra(prev);
if !statements::pgss_installed(cx).await {
if !extra.warned_missing {
tracing::warn!(server = cx.target.server_id, instance = cx.target.instance,
"pg_stat_statements is not installed in the maintenance database; run CREATE EXTENSION pg_stat_statements there");
extra.warned_missing = true;
}
return Ok(statements::empty(
self.name(),
KEY,
cx,
&extra,
Default::default(),
));
}
extra.warned_missing = false;
// aurora_stat_statements exists from APG 14.9 / 15.4; peakmem columns from 14.12 / 15.7 / 16.3.
// We only use the Aurora function when the peakmem columns exist, to keep one SQL shape.
let aurora =
cx.caps.aurora && aurora_has_peakmem(cx.caps.aurora_version.as_deref(), cx.pg_version);
let (func, extra_cols) = if aurora {
("aurora_stat_statements(false)", statements::AURORA_COLUMNS)
} else {
("pg_stat_statements(false)", "")
};
let ext = statements::pgss_version(cx);
let stale_event = statements::stale_report(cx, &mut extra);
if ext < statements::MIN_PGSS_VERSION {
let (mut snap, state) =
statements::empty(self.name(), KEY, cx, &extra, Default::default());
snap.events.extend(stale_event);
return Ok((snap, state));
}
let cols = statements::pgss_columns(ext);
let src = Source {
name: "query_stats",
aux_name: "queries",
stats_sql: format!(
"SELECT s.queryid, {cols} {extra_cols} s.queryid AS _id
FROM {func} s JOIN pg_database d ON d.oid = s.dbid LEFT JOIN pg_roles r ON r.oid = s.userid
WHERE s.queryid IS NOT NULL"
),
key: KEY,
text_sql: format!(
"SELECT DISTINCT ON (s.queryid, d.datname) s.queryid, d.datname,
left(s.query, {n}) AS query, length(s.query) > {n} AS truncated
FROM pg_stat_statements(true) s JOIN pg_database d ON d.oid = s.dbid
WHERE s.queryid = ANY($1) ORDER BY s.queryid, d.datname, s.calls DESC",
n = statements::MAX_TEXT_BYTES
),
text_key: &["queryid", "datname"],
};
let (mut snap, state) = statements::collect(&src, cx, prev, extra, true).await?;
snap.events.extend(stale_event);
Ok((snap, state))
}
}
/// aurora_version() looks like "16.3.0" / "15.7.1"; peakmem columns landed in 14.12 / 15.7 / 16.3.
pub fn aurora_has_peakmem(aurora_version: Option<&str>, pg_version: u32) -> bool {
let Some(v) = aurora_version else {
return false;
};
let mut it = v.split('.').filter_map(|p| p.parse::<u32>().ok());
let (major, minor) = (it.next().unwrap_or(0), it.next().unwrap_or(0));
match major {
14 => minor >= 12,
15 => minor >= 7,
16 => minor >= 3,
m if m >= 17 => true,
_ => pg_version >= 170000,
}
}