Trace every failure
back to the request that caused it
Errors, performance traces, and request analytics from your Node.js services — captured off the main thread, grouped by root cause, and queryable in a ClickHouse-backed console built for the engineers who ship the fix.
- Async, non-blocking dispatch
- Open-source Node.js SDK
- Self-hostable ingestion
import { VantaTrace } from '@vantatrace/sdk';
const vantaTrace = new VantaTrace({
apiKey: process.env.VANTATRACE_API_KEY,
});
app.use(vantaTrace.requestHandler());
// uncaught exceptions, rejections, and
// silent 5xxs — captured automatically.Built for the stack you already run
Built for your architecture.
From massive monoliths to ephemeral serverless functions, VantaTrace adapts to how you ship code.
Trace a single request as it hops across 10 different services.
Stop guessing which service dropped the ball. VantaTrace automatically propagates trace headers across HTTP boundaries, stitching together a unified root-cause analysis for distributed architectures.
- Automatic Trace ID propagation
- Cross-service stack trace stitching
- Identifies the exact failing downstream node
// auth-service.js
const { captureException, getActiveTraceId } = require('@vantatrace/sdk');
app.post('/verify', async (req, res) => {
try {
await verifyToken(req.body.token);
} catch (err) {
captureException(err, {
metadata: { service: 'auth-service' }
});
// The exact Trace ID is passed to checkout-service
res.status(401).json({ error: 'Invalid Token', traceId: getActiveTraceId() });
}
});One console for everything that can go wrong
Most teams stitch together a logger, an APM, and a spreadsheet of incident notes. VantaTrace replaces the stitching with one pipeline from request to root cause.
Errors
Uncaught exceptions, unhandled rejections, and silently swallowed try/catch failures — captured with full stack, request context, and a synthetic trace when the source is hidden.
Performance
Per-route latency, throughput, and slow-endpoint detection — so a regression shows up in the console before it shows up in a support ticket.
Tracing
Follow a single request as it crosses services. Correlation IDs tie the gateway hop to the worker hop to the database call it eventually blamed.
Logs
The events leading up to a failure, not just the failure itself — console, Winston, and Pino output normalized into one readable timeline.
Metrics
Redis-backed counters update on ingest, so quota, error-rate, and volume widgets reflect what happened seconds ago — not last night’s batch job.
Analytics
Every occurrence lands in a columnar store built for scans, not lookups — filter by MSISDN, user, project, or environment without a slow query in sight.
A console that reads like your incident channel, not a spreadsheet
Switch between issues, performance, and traces without leaving the page — everything shares the same time range, the same filters, the same request.
Issue explorer
Grouped by fingerprint, sorted by impact, filterable by environment, service, or MSISDN.
Performance graphs
p50/p95/p99 latency and throughput, per route, updated in real time.
Request waterfall
A span-level breakdown of where a slow request actually spent its time.
Two lines in, five minutes to your first issue
The same middleware wires into whatever's already serving your Node.js requests.
import express from 'express';
import { VantaTrace } from '@vantatrace/sdk';
const app = express();
const vantaTrace = new VantaTrace({ apiKey: process.env.VANTATRACE_API_KEY });
app.use(vantaTrace.requestHandler());
// ...your routes...
app.use(vantaTrace.errorHandler());
app.listen(3000);An ingestion path designed for traffic you haven't hit yet
A telemetry agent that slows down the thing it's watching defeats the point. VantaTrace dispatches asynchronously, queues through Redis and BullMQ, and writes into ClickHouse — so a traffic spike in your app becomes a queue depth, not an incident in your API.
Async by default
Capture is queued via BullMQ and shipped off the request thread. Nothing you instrument ever adds latency to a response.
Redis-backed counters
Quota and rate metrics update on ingest, not on a nightly rollup — the dashboard reflects what happened seconds ago.
ClickHouse storage
Occurrences land in a columnar store built to scan millions of rows per query — filter by project, user, or MSISDN without a slow query in sight.
Stateless workers
Ingestion workers hold no local state. Scale out horizontally when volume grows; nothing to re-architect.
How an exception becomes an issue
Five steps, none of them blocking the request that triggered them.
SDK
Middleware captures the exception, context, and request metadata in-process.
Queue
Payload is pushed onto a BullMQ job and the request thread moves on immediately.
Worker
A stateless worker normalizes, redacts, and groups the event by fingerprint.
ClickHouse
The occurrence is written to a columnar store built for fast, wide scans.
Dashboard
Issue, trend, and project views query ClickHouse and update live.
Everything an on-call engineer actually reaches for
Error Monitoring
Every unhandled error, captured with full context.
Exception Tracking
Swallowed try/catch failures recovered at the throw site.
Performance Monitoring
Per-route latency and slow-endpoint detection.
Distributed Tracing
Follow a request as it crosses services.
Request Analytics
Filter by project, user, environment, or MSISDN.
API Monitoring
Status codes, response bodies, and route health.
ClickHouse Analytics
A columnar store built for scans, not lookups.
Session Insights
User, tenant, and session context on every occurrence.
Smart Issue Grouping
Fingerprinted by name, message, and stack location.
Real-time Dashboards
Redis-backed counters update the moment events land.
Alerts
In-app, live socket, and Slack alerts on new issues.
SDKs
One middleware for Node.js, Express, and NestJS.
Multi-language Support
Console localizes to your team, not just your stack.
Questions engineers actually ask
Everything you need to know about overhead, security, architecture, and framework integration.
Any Node.js server that exposes an Express-style (req, res, next) request cycle — Express and NestJS directly, plus a raw-HTTP adapter for everything else. Framework-specific SDKs beyond that are on the roadmap, not shipped yet.
Capture is dispatched asynchronously and queued through BullMQ. The request thread never waits on ingestion, and if the ingestion backend is unreachable, the SDK fails silently rather than throwing.
Occurrences are written to ClickHouse, a columnar store built for fast scans over large volumes. Project and account metadata live in MongoDB.
Yes — every occurrence can carry a userId and MSISDN (extracted from request headers or your auth payload), so you can trace an incident back to the exact account or phone number affected.
Known sensitive keys — passwords, tokens, secrets, PINs, credit-card-shaped strings — are redacted before anything is stored, both in the SDK and again in the ingestion worker.
Plans are scoped by monthly request volume and number of active projects. Start on the free tier and move up as your traffic grows — no usage surprises mid-cycle.
Have architectural or custom deployment questions?
Explore our full SDK reference or get in touch with our technical support team.