Trace every request across services, jobs and dependencies to see exactly where time is spent and where things go wrong.

Attach your subsystems once and every query, login and job execution is traced. No manual span wiring at any call site.

See every step of a request with self time and total time per span, so you know exactly where latency comes from.

Profile any region with the V8 inspector and read self time per function, down to the file and line that held the CPU.

Every response carries where its time went in a standard header your browser devtools already understand.

Turn a failing trace into a self-contained prompt — or connect your coding agent directly via MCP, with the stack, source, timings and logs it needs.

Automatically group identical failures into one issue, keyed by a normalized message and the top application frame.

See the failing file and line, the full stack, and the breadcrumbs that led there — without checking out the build yourself.

Every issue carries the users and requests it happened to, so you can tell a one-off from an outage.

See every log line exactly where it happened in the trace, automatically connected to the request or job that produced it.

Collect page timings and navigation data from the browser, joined to the server trace by trace id.

Track which release introduced a defect and automatically reopen resolved issues when the same failure comes back.

Turn any error, trace, request or job into an actionable issue with severity, ownership, due dates, comments and a complete activity history.

Track queue wait time, retries and failures alongside your requests, with alerts when a backlog starts growing before it becomes an incident.

Monitor CPU, memory and event-loop delay per process, with automatic detection when one instance starts carrying the load.

See how requests move through your application and where failures happen, so you can spot the exact path that leads to a problem.

A trace waterfall, stack inspection and live refresh ship with the framework. No agent to install, no pipeline to build.

Scope issues to the users they affect, so one noisy account does not read as one widespread outage.

Compare releases by error rate, p50/p95/p99 and slow queries, plus which error fingerprints each one introduced or fixed.

Alert on error-budget burn rate instead of isolated spikes, so fast-moving incidents and slow degradation surface before they page anyone.

Define SLOs per route and method with a rolling error budget and burn rate. Too little traffic reports no-data instead of a verdict.

Adaptive baselines catch drift against each metric's own history, using median and MAD so one stall cannot hide the event.

Detect silent failures automatically — from an application that stops receiving traffic to a cron job that never runs.

Alert on errors, anomalies, SLO burn, log patterns, or things that stop happening — with notifications through email, Slack, webhooks, or issues.

Correlates the failing trace, its slow queries, release proximity and rule-outs into ranked suspects with an ordered timeline.

Every claim carries the evidence behind it and the reasons it could be wrong. Gaps are reported as Unknown rather than smoothed over.

Too few samples for a baseline, a metric with no observed variance, a first release with nothing to compare — each declines instead of guessing.

Compares the running release against the previous one: signed deltas, new error fingerprints, and which failures stopped.

Per-release errors, p50/p95/p99, slow queries and affected routes, with a verdict derived from a real comparison rather than assumed.

Finds identical queries repeated under one parent — the N+1 shape specifically — and estimates the avoidable cost.

Per-query slow thresholds derived from each query's own rolling p95, so a table that normally takes 400ms is no longer all flagged.

Availability, remaining budget and burn rate per objective. A 5xx counts against availability; a 4xx does not.

Least-squares trend with fit quality. A weak fit is reported as noise rather than called a leak.

Mark a known-good run, then see exactly which step got slower, appeared or vanished in a later trace.

A call graph inferred from spans, with the limitations stated on the result rather than left to be discovered.

Destructive operations are previewed, confirmed, and need an idempotency key so a double-click cannot purge twice.

A self-contained JSON payload with evidence, caveats and timeline — designed for a model or a colleague with no access to your process.

Jump from a stack frame to the source line, with a resolver you opt into. Production bundles ship no sources, and it says so.

Cmd/Ctrl-K to jump to a view, open a trace by id, export an incident, or save a golden baseline.

Each cluster worker has its own observer. No leader aggregation yet — the dashboard shows one process.

Issues and transactions vanish on restart today. Persisting them needs retention and rotation.

Error-rate spikes, p95 thresholds, blocked event loops, heap growth, with dedupe windows and quiet hours.

Tracing inbound but not outbound is the missing half of distributed tracing. Needed before the dependency map shows external services.

Keep 100% of error and slow traces while sampling fast successes. The span tree is already there to make the decision.

Track custom counters, gauges and histograms — from orders processed to queue depth — through the metrics registry, alongside built-in metrics.

Your registry is already served in text exposition format at /_yatta/metrics. Point a scraper at it and nothing else changes.

Sampling is the honest gap: tracesSampleRate is accepted and validated, but no head-sampling decision is made yet, so every span is recorded. Everything is in-process and nothing is ingested anywhere.