: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
//! REST surface. Handlers are thin: parse params, call `queries`, return JSON.
use crate::auth::Principal;
use crate::config::Range;
use crate::queries as q;
use crate::AppState;
use axum::{
extract::{Extension, Path, Query, State},
http::StatusCode,
middleware::map_response,
response::{IntoResponse, Json, Response},
routing::get,
Router,
};
use chrono::{DateTime, Utc};
use serde::Deserialize;
use std::sync::Arc;
/// A page left open across a deploy sees a new token on its next API call and reloads,
/// instead of running the old script against the new API.
async fn stamp_build(mut res: Response) -> Response {
res.headers_mut()
.insert("x-pgapi-build", crate::ui::BUILD_TOKEN.clone());
res
}
type S = State<Arc<AppState>>;
pub struct ApiError(anyhow::Error);
impl<E: Into<anyhow::Error>> From<E> for ApiError {
fn from(e: E) -> Self {
Self(e.into())
}
}
impl IntoResponse for ApiError {
fn into_response(self) -> Response {
let msg = format!("{:#}", self.0);
let code = if msg.contains("range") || msg.contains("allowed") || msg.contains("only") {
StatusCode::BAD_REQUEST
} else {
StatusCode::INTERNAL_SERVER_ERROR
};
(code, Json(serde_json::json!({ "error": msg }))).into_response()
}
}
type R = Result<Json<serde_json::Value>, ApiError>;
pub fn router() -> Router<Arc<AppState>> {
Router::new()
.route("/me", get(me))
.route("/servers", get(servers))
.route("/servers/:server/overview", get(overview))
.route("/servers/:server/load", get(load))
.route("/servers/:server/queries", get(top_queries))
.route("/servers/:server/queries/:queryid", get(query_detail))
.route("/servers/:server/tags", get(tags))
.route("/servers/:server/waits", get(waits))
.route("/servers/:server/locks", get(locks))
.route("/servers/:server/sessions/:pid", get(session_history))
.route("/servers/:server/activity", get(activity))
.route("/servers/:server/tables", get(tables))
.route("/servers/:server/indexes", get(indexes))
.route("/servers/:server/vacuum", get(vacuum))
.route("/servers/:server/events", get(events))
.route("/servers/:server/settings", get(settings))
.route("/servers/:server/schema", get(schema))
.route("/servers/:server/logs", get(logs))
.route("/servers/:server/system", get(system))
.route("/servers/:server/cpu", get(cpu))
.route("/servers/:server/checkpoints", get(checkpoints))
.route("/collector/health", get(collector_health))
.route("/sql", get(sql))
.route("/stats-schema", get(stats_schema))
.layer(map_response(stamp_build))
}
async fn me(Extension(p): Extension<Principal>) -> R {
Ok(Json(serde_json::to_value(p)?))
}
async fn servers(State(s): S) -> R {
Ok(Json(q::servers(&s.db).await?))
}
async fn overview(State(s): S, Path(server): Path<String>, Query(r): Query<Range>) -> R {
let (f, t) = r.resolve()?;
Ok(Json(q::overview(&s.db, &server, f, t).await?))
}
#[derive(Deserialize)]
struct TopQ {
#[serde(flatten)]
range: Range,
datname: Option<String>,
#[serde(default = "d_order")]
order: String,
#[serde(default = "d_limit")]
limit: i64,
/// `key=value,key2=value2`: only queries seen with these tags in the range. A comma
/// inside a value is sent as `%2C`.
tags: Option<String>,
}
fn d_order() -> String {
"total_exec_time".into()
}
fn d_limit() -> i64 {
50
}
async fn top_queries(State(s): S, Path(server): Path<String>, Query(p): Query<TopQ>) -> R {
let (f, t) = p.range.resolve()?;
let tags = q::parse_tag_filter(p.tags.as_deref().unwrap_or(""))?;
Ok(Json(
q::top_queries(
&s.db,
&server,
f,
t,
q::QueryListOpts {
datname: p.datname.as_deref(),
order: &p.order,
limit: p.limit.clamp(1, 500),
tags: &tags,
},
)
.await?,
))
}
#[derive(Deserialize)]
struct TagsQ {
#[serde(flatten)]
range: Range,
key: Option<String>,
datname: Option<String>,
#[serde(default = "d_limit")]
limit: i64,
}
async fn tags(State(s): S, Path(server): Path<String>, Query(p): Query<TagsQ>) -> R {
let (f, t) = p.range.resolve()?;
Ok(Json(
q::tag_breakdown(
&s.db,
&server,
f,
t,
p.key.as_deref(),
p.datname.as_deref(),
p.limit,
)
.await?,
))
}
#[derive(Deserialize)]
struct BucketQ {
#[serde(flatten)]
range: Range,
#[serde(default = "d_bucket")]
bucket: String,
/// Limit text and series to one database when the query id exists in several.
datname: Option<String>,
}
fn d_bucket() -> String {
"1m".into()
}
async fn query_detail(
State(s): S,
Path((server, queryid)): Path<(String, i64)>,
Query(p): Query<BucketQ>,
) -> R {
let (f, t) = p.range.resolve()?;
Ok(Json(
q::query_detail(
&s.db,
&server,
queryid,
f,
t,
&p.bucket,
p.datname.as_deref(),
)
.await?,
))
}
async fn load(State(s): S, Path(server): Path<String>, Query(p): Query<BucketQ>) -> R {
let (f, t) = p.range.resolve()?;
Ok(Json(q::db_load(&s.db, &server, f, t, &p.bucket).await?))
}
async fn waits(State(s): S, Path(server): Path<String>, Query(p): Query<BucketQ>) -> R {
let (f, t) = p.range.resolve()?;
Ok(Json(q::wait_events(&s.db, &server, f, t, &p.bucket).await?))
}
#[derive(Deserialize)]
struct LocksQ {
#[serde(flatten)]
range: Range,
#[serde(default = "d_bucket")]
bucket: String,
#[serde(default = "d_limit")]
limit: i64,
}
async fn locks(State(s): S, Path(server): Path<String>, Query(p): Query<LocksQ>) -> R {
let (f, t) = p.range.resolve()?;
Ok(Json(
q::lock_waits(&s.db, &server, f, t, &p.bucket, p.limit.clamp(1, 500)).await?,
))
}
#[derive(Deserialize)]
struct SessionQ {
#[serde(flatten)]
range: Range,
#[serde(default = "d_instance")]
instance: String,
/// The backend's start time, which tells a reused pid apart from the one asked about.
backend_start: Option<DateTime<Utc>>,
/// Without `backend_start`, the backend sampled nearest to this time is the one returned.
at: Option<DateTime<Utc>>,
}
fn d_instance() -> String {
"writer".into()
}
async fn session_history(
State(s): S,
Path((server, pid)): Path<(String, i64)>,
Query(p): Query<SessionQ>,
) -> R {
let (f, t) = p.range.resolve()?;
Ok(Json(
q::session_history(
&s.db,
&server,
&p.instance,
pid,
q::SessionWindow {
from: f,
to: t,
backend_start: p.backend_start,
at: p.at,
},
)
.await?,
))
}
async fn activity(State(s): S, Path(server): Path<String>) -> R {
Ok(Json(q::current_activity(&s.db, &server).await?))
}
#[derive(Deserialize)]
struct DbQ {
#[serde(flatten)]
range: Range,
datname: String,
#[serde(default = "d_limit")]
limit: i64,
}
async fn tables(State(s): S, Path(server): Path<String>, Query(p): Query<DbQ>) -> R {
let (f, t) = p.range.resolve()?;
Ok(Json(
q::tables(&s.db, &server, &p.datname, f, t, p.limit.clamp(1, 2000)).await?,
))
}
async fn indexes(State(s): S, Path(server): Path<String>, Query(p): Query<DbQ>) -> R {
let (f, t) = p.range.resolve()?;
Ok(Json(q::indexes(&s.db, &server, &p.datname, f, t).await?))
}
#[derive(Deserialize)]
struct OptDbQ {
#[serde(flatten)]
range: Range,
datname: Option<String>,
kind: Option<String>,
/// Comma-separated `LIKE` patterns of event kinds to leave out, applied before the limit.
exclude: Option<String>,
relname: Option<String>,
#[serde(default = "d_limit")]
limit: i64,
#[serde(default)]
non_default: bool,
}
async fn vacuum(State(s): S, Path(server): Path<String>, Query(p): Query<OptDbQ>) -> R {
let (f, t) = p.range.resolve()?;
Ok(Json(
q::vacuum(&s.db, &server, p.datname.as_deref(), f, t).await?,
))
}
async fn events(State(s): S, Path(server): Path<String>, Query(p): Query<OptDbQ>) -> R {
let (f, t) = p.range.resolve()?;
Ok(Json(
q::events(
&s.db,
&server,
f,
t,
p.kind.as_deref(),
&q::split_list(p.exclude.as_deref()),
p.limit.clamp(1, 1000),
)
.await?,
))
}
async fn settings(State(s): S, Path(server): Path<String>, Query(p): Query<OptDbQ>) -> R {
Ok(Json(q::settings(&s.db, &server, p.non_default).await?))
}
async fn schema(State(s): S, Path(server): Path<String>, Query(p): Query<OptDbQ>) -> R {
let datname = p
.datname
.ok_or_else(|| anyhow::anyhow!("datname is required"))?;
Ok(Json(
q::schema(&s.db, &server, &datname, p.relname.as_deref()).await?,
))
}
async fn logs(State(s): S, Path(server): Path<String>, Query(p): Query<OptDbQ>) -> R {
let (f, t) = p.range.resolve()?;
Ok(Json(
q::log_errors(&s.db, &server, f, t, p.limit.clamp(1, 1000)).await?,
))
}
async fn system(State(s): S, Path(server): Path<String>, Query(r): Query<Range>) -> R {
let (f, t) = r.resolve()?;
Ok(Json(q::system(&s.db, &server, f, t).await?))
}
async fn cpu(State(s): S, Path(server): Path<String>, Query(r): Query<Range>) -> R {
let (f, t) = r.resolve()?;
Ok(Json(q::cpu(&s.db, &server, f, t).await?))
}
async fn checkpoints(State(s): S, Path(server): Path<String>, Query(r): Query<Range>) -> R {
let (f, t) = r.resolve()?;
Ok(Json(q::checkpoints(&s.db, &server, f, t).await?))
}
async fn collector_health(State(s): S) -> R {
Ok(Json(q::collector_health(&s.db).await?))
}
#[derive(Deserialize)]
struct SqlQ {
sql: String,
#[serde(default = "d_sql_limit")]
limit: i64,
}
fn d_sql_limit() -> i64 {
200
}
async fn sql(State(s): S, Extension(p): Extension<Principal>, Query(qs): Query<SqlQ>) -> R {
tracing::info!(email = p.email, sql = qs.sql, "raw sql");
Ok(Json(q::raw_sql(&s.db, &qs.sql, qs.limit).await?))
}
async fn stats_schema(State(s): S) -> R {
Ok(Json(q::schema_of_stats_db(&s.db).await?))
}
pub async fn readyz(State(s): S) -> Response {
if s.db.ping().await {
(StatusCode::OK, "ready").into_response()
} else {
(StatusCode::SERVICE_UNAVAILABLE, "stats db unreachable").into_response()
}
}
pub async fn metrics() -> Response {
use prometheus::Encoder;
let mut buf = Vec::new();
prometheus::TextEncoder::new()
.encode(&prometheus::gather(), &mut buf)
.ok();
([("content-type", "text/plain; version=0.0.4")], buf).into_response()
}