Node.js SDK - Steadwing

What is the Steadwing Node SDK?

The Steadwing Node SDK auto-captures exceptions, error logs, and HTTP breadcrumbs from your Node.js applications and sends them to Steadwing for root cause analysis. Add two lines of code and Steadwing starts monitoring your application no manual instrumentation required.

Auto-Capture

Unhandled exceptions, rejections, and error logs captured automatically

HTTP Breadcrumbs

Outgoing HTTP/HTTPS requests recorded with method, URL, status, and duration

Express & Fastify

Route error capture with full request context

Data Scrubbing

Sensitive fields (passwords, tokens, API keys) redacted before sending

Installation

npm install @steadwing/node

Requires Node.js 18+. View on npm or browse the source on GitHub.

Quick Start

Get your API key from app.steadwing.com/organization, then initialize the SDK:

const steadwing = require("@steadwing/node");

steadwing.init({
    apiKey: "st_your_api_key"
});

That’s it. The SDK automatically:

Captures unhandled exceptions (uncaughtException)
Captures unhandled promise rejections (unhandledRejection)
Captures console.error(), winston, and pino error-level logs
Records outgoing HTTP/HTTPS requests as breadcrumbs
Sends heartbeats every 60 seconds

Configuration

steadwing.init({
    apiKey: "st_...",          // Required: your API key
    service: "my-service",    // Optional: defaults to "default"
    env: "PROD",              // Optional: defaults to "PROD"
    enabled: true,            // Optional: set false to disable
});

Only events sent with env="PROD" are considered for auto-monitoring. Events from other environments are received but will not trigger automated RCA.

Manual Capture

For cases where you want to explicitly report errors or messages:

Capture Exception
Capture Message

const steadwing = require("@steadwing/node");

// Capture a specific exception
try {
    riskyOperation();
} catch (err) {
    steadwing.captureException(err);
}

const steadwing = require("@steadwing/node");

steadwing.captureMessage("Deployment completed", "info");

What Gets Captured

Exceptions

Data	Description
Stack trace	Full V8 stack trace with file, line, and column
Exception chain	`Error.cause` chain included
Breadcrumbs	Last 100 events leading up to the error
Request context	Method, path, headers (when using framework middleware)

Logs

console.error() sent as events
Winston error/crit/emerg-level logs sent as events
Pino error/fatal-level logs sent as events
All log levels recorded as breadcrumbs for context

HTTP Breadcrumbs

Every outgoing HTTP/HTTPS request is recorded with:

Method and URL
Response status code
Request duration
Rolling buffer of last 100 entries

Data Scrubbing

Sensitive data is automatically scrubbed before leaving your application. Keys matching the following patterns (case-insensitive) have their values replaced with [REDACTED]:

password, passwd, secret, api_key, apikey, token, auth,
authorization, cookie, csrf, session, credit_card, ssn

Framework Support

Framework	What’s Captured
Express	Route errors with full request context (method, path, headers)
Fastify	Route errors with request context via onError hook
winston	Error-level log capture (auto-detected)
pino	Error-level log capture (auto-detected)

Express

Add the error handler as your last middleware:

const steadwing = require("@steadwing/node");
const express = require("express");

steadwing.init({ apiKey: "st_..." });

const app = express();

app.get("/", (req, res) => res.send("ok"));
app.get("/fail", (req, res, next) => next(new Error("DB timeout")));

// Add as the last middleware
app.use(steadwing.expressErrorHandler());

app.listen(3000);

Fastify

const steadwing = require("@steadwing/node");
const fastify = require("fastify");

steadwing.init({ apiKey: "st_..." });

const app = fastify();
app.register(steadwing.fastifyErrorHandler());

app.listen({ port: 3000 });

Winston and pino are captured automatically when installed, no extra code needed.

TypeScript

Full TypeScript support with exported types:

import { init, captureException, expressErrorHandler } from "@steadwing/node";
import type { SteadwingConfig } from "@steadwing/node";

const config: SteadwingConfig = {
    apiKey: "st_...",
    service: "my-service",
};

init(config);

FAQs

Do I need to change my code?

No. After calling steadwing.init(), the SDK hooks into Node’s exception handling, console, and HTTP modules automatically. For Express/Fastify request context, add one line of middleware.

What's the performance impact?

Minimal. Events are batched and sent every 5 seconds in a non-blocking flush. Breadcrumbs are stored in a fixed-size buffer. Timers use unref() so the SDK never keeps your process alive.

Can I disable it in development?

Yes. Pass enabled: false to steadwing.init() and the SDK becomes a no-op, no patches are installed and no events are sent.

How does it work with existing error tracking (Sentry, etc.)?

The SDK coexists with other error trackers. It listens on process.on('uncaughtException') and patches console.error without removing existing listeners or handlers.

Is my data secure?

Sensitive fields are scrubbed before transmission. Data is sent over HTTPS to Steadwing’s backend. See the Data Scrubbing section for details on what’s redacted.

Need help? Contact us at hello@steadwing.com

​What is the Steadwing Node SDK?

Auto-Capture

HTTP Breadcrumbs

Express & Fastify

Data Scrubbing

​Installation

​Quick Start

​Configuration

​Manual Capture

​What Gets Captured

​Exceptions

​Logs

​HTTP Breadcrumbs

​Data Scrubbing

​Framework Support

​Express

​Fastify

​TypeScript

​FAQs

What is the Steadwing Node SDK?

Installation

Quick Start

Configuration

Manual Capture

What Gets Captured

Exceptions

Logs

HTTP Breadcrumbs

Data Scrubbing

Framework Support

Express

Fastify

TypeScript

FAQs