moniof

moniof (Monitor Over Fetch) is an Actix Web middleware and instrumentation crate that detects N+1 / over-fetch patterns, tracks per-request DB latency, exposes Prometheus metrics, and sends Slack alerts. It works with MongoDB (via command events) and SQLx (via tracing spans). Inspired by Ruby’s bullet gem — but built for Rust + Actix.

• Actix middleware (MoniOF) that scopes DB stats to each request
• N+1 & over-fetch detection with configurable thresholds
• MongoDB instrumentation via CommandEventHandler
• SQLx instrumentation via a tracing Layer (installed automatically)
• Prometheus metrics and per-response x-moniof-* headers
• Slack alerts for request-level anomalies and slow / failed DB commands

Call initiate() once in main(). It installs a tracing subscriber (reading RUST_LOG, then adding moniof + sqlx directives), installs the SQLx layer when the sqlx feature is on, and stores the global config.

use moniof::{MoniOFGlobalConfig, initiate as moniof_initiate};

fn main() {
    moniof_initiate(MoniOFGlobalConfig {
        log_each_db_event: false,
        slow_db_threshold_ms: Some(100),
        low_db_threshold_ms: None,
        slack_webhook: None,        // Some("https://hooks.slack.com/...".into())
        ..Default::default()
    });

    // Start Actix...
}

The process-wide config (all fields default to false / None). It governs Mongo command logging and Slack; it is not where N+1 thresholds live.

Wrap your Actix app. MoniOF::new() uses the default per-request config; MoniOF::with_config(cfg) customizes it. Each request installs a task-local stats handle so DB instrumentation records into that request’s scope, then computes counts, latency, and N+1 suspects.

use moniof::MoniOF;

HttpServer::new(|| {
    App::new()
        .wrap(MoniOF::new())
})

A separate struct passed to MoniOF::with_config — it drives thresholds, headers, and N+1 detection.

Attach MOFMongoEvents as the command event handler so every command is counted and timed. Keys are namespaced as mongo/{collection}/{op}.

use moniof::MOFMongoEvents;
use std::sync::Arc;
use mongodb::{Client, options::ClientOptions};

let mut opts = ClientOptions::parse(&mongo_uri).await?;
opts.command_event_handler = Some(Arc::new(MOFMongoEvents::default()));

let client = Client::with_options(opts)?;
let db = client.database("mydb");

With the sqlx feature enabled, initiate() installs the MOFSqlEvents tracing layer automatically — you do not attach anything manually. It hooks spans under the sqlx::query target, normalizes the SQL (whitespace-collapsed, lowercased, truncated to 200 chars) into a sql/{normalized} key, and records count + latency.

let rows = sqlx::query!("SELECT id FROM users")
    .fetch_all(pool)
    .await?;
// moniof::sql: SQL completed key="select id from users" latency_ms=2

Register the async prom::metrics_handler as an Actix route (note: metrics_handler, not metrics). init_prometheus() is idempotent and called lazily.

use actix_web::web;

App::new()
    .wrap(moniof::MoniOF::new())
    .route("/metrics", web::get().to(moniof::prom::metrics_handler))

When add_response_headers is true, each response carries request-scoped timing (only the N+1 headers require of_mode and at least one suspect).

x-moniof-total: 5                  # total query count
x-moniof-elapsed-ms: 18            # request elapsed
x-moniof-db-total-ms: 12           # cumulative DB latency
x-moniof-slowest-key: users/find   # slowest single key
x-moniof-slowest-latency-ms: 9
x-moniof-n-plus-one-key: users/find
x-moniof-n-plus-one-count: 5
x-moniof-n-plus-one-total-ms: 7

When of_mode is on, find_suspects scans each key: it skips keys repeated fewer than n_plus_one_min_count (default 5) times, and (if n_plus_one_min_total_ms is set) those whose cumulative latency is below the minimum. Remaining keys are ranked by count then latency, and the top 3 become suspects (surfaced in the headers and warnings).

Slack alerts fire only when slack_webhook is set. Triggers: request-level anomalies (high total, repeated key, high/low cumulative latency, or N+1 suspects) when log_warnings is on; a slow MongoDB command (slow_db_threshold_ms); and every failed MongoDB command.