who did what, when,
and what it cost.

Three steps

From nothing to a queryable trail.

No agent to run, no schema to design, no table to migrate. The SDK batches in the background and flushes on exit, so a serverless invocation does not drop its last events.

1. 01

   Install

   One package. Adapters for Hono, Express and Nitro ship as subpath exports.

   terminal

   $ bun add nitroping

2. 02

   Record

   track() returns immediately — it queues. A slow endpoint never slows the request you are auditing.

   app.ts

   import { NitroPing } from "nitroping"
   
   const audit = new NitroPing({ apiKey: process.env.NITROPING_KEY! })
   
   audit.track({
     actor_id: user.id,
     actor_type: "user",
     action: "invoice.void",
     target_type: "invoice",
     target_id: invoice.id,
     severity: "warning",
     metadata: { amount_cents: 42_900, reason: "duplicate" },
   })

3. 03

   Read it back

   Filter, group and follow a session in the panel — or let an agent do it: bunx nitroping-mcp logs itself in, no key to paste, and can mark what it finds resolved.

   mcp tools

   • project_health
   • error_groups
   • find_errors
   • endpoint_health
   • actor_summary
   • list_events
   • resolve_error
   • list_error_states

For agents

Hand it to the thing that writes your code.

The whole integration is one file, written to be read by a model: the event shape, the four fields the server owns, the middleware, the GenAI wrappers, and the rules for not filling an audit log with noise. Paste this and let the agent do the wiring.

Integrity

Four fields the caller does not get to choose.

An audit log is only worth keeping if the parts that matter cannot be written by the thing being audited. These are stamped at the endpoint, after the request is authenticated and before the row exists.

idserver-assigned

UUIDv7, assigned on write.

Time-ordered, so a row's position in the log is a fact about when it happened, not about when it arrived.

tenant_idserver-assigned

Taken from the API key.

A client that posts its own tenant_id is overwritten with the key's. There is no way to write into someone else's log.

ipserver-assigned

Read from the connection.

Never accepted from the body. Send X-NitroPing-No-IP and the row is written without it rather than blanked afterwards.

timestampserver-assigned

Normalised to UTC milliseconds.

One conversion, in one place. A client sending +03:00 does not land three hours out.

GenAI

The same log, priced.

Model calls are actions with an actor, a target and a cost. They belong in the audit trail rather than in a second tool — so the wrappers write to the same table, and the cost lands on the row.

import { NitroPing } from "nitroping"

const audit = new NitroPing({ apiKey: process.env.NITROPING_KEY! })
const openai = audit.observeOpenAI(new OpenAI())

// Nothing else changes. Every call now writes a row with
// input_tokens, output_tokens, cached_input_tokens and cost_usd.
await openai.chat.completions.create({ model: "gpt-4o-mini", messages })

Integration

Or send nothing at all.

Middleware turns every request into an http.request event with method, path, status and latency. If your service already speaks OpenTelemetry, point the exporter here and skip the SDK.

import { nitropingMiddleware } from "nitroping/hono"

app.use(nitropingMiddleware({
  apiKey: process.env.NITROPING_KEY!,
  getActor: (c) => c.get("user"),
}))

OTEL_EXPORTER_OTLP_ENDPOINT=https://ingest.nitroping.dev/v1/otlp
OTEL_EXPORTER_OTLP_HEADERS="Authorization=Bearer $NITROPING_KEY"

Control

It is your log.

Two things a hosted audit log has to answer for: getting a person out of it, and not being the only place it can run.