⚡ Crashless

Production-Ready Observability for Node.js
Zero npm-dependency middleware that prevents Express servers from crashing and provides built-in monitoring — all from a single line of code.

---

🚀 Quick Start

npm install crashless

import express from 'express';
import crashless from 'crashless';

const app = express();
app.use(crashless()); // 🎉 That's it!

app.get('/users/:id', async (req, res) => {
  const user = await db.getUser(req.params.id); // 🛡️ Errors safely caught
  res.json(user);
});

app.listen(3000);

🖥️ Dashboard: http://localhost:3000/_crashless

---

🎮 Try It Live

▶️ One-Liner Setup
Simplest possible setup

▶️ Full Featured Demo
All features enabled

▶️ OpenTelemetry
OTel metrics & traces

▶️ Prometheus Export
Prometheus-compatible metrics

▶️ Custom Exporters
Sentry, Datadog integrations

▶️ Production Dashboard
Secure production setup

Or clone locally:

git clone https://github.com/sunnyghodeswar/crashless-examples.git
cd crashless-examples && npm install

📚 Documentation

📖 Complete Docs
Full documentation site

🚀 Getting Started
Installation & setup guide

⚙️ Configuration
All configuration options

📋 API Reference
Complete API documentation

💡 Examples
Common use cases & patterns

⚡ Performance
Benchmarks & optimization

---

✨ Key Features

🛡️ Automatic Error Handling

Catch all errors automatically—sync, async, and promises. No try-catch needed.

app.use(crashless());

// Async errors - automatically caught
app.get('/data', async (req, res) => {
  const data = await fetchData(); // 🛡️ Safe
  res.json(data);
});

// Sync errors - also caught
app.get('/test', (req, res) => {
  throw new Error('Oops'); // 🛡️ Safe
});

📊 Built-in Dashboard

Real-time observability dashboard with three powerful views:

• System Dashboard - Request metrics, throughput, latency, route performance
• Errors Dashboard - Error frequency, top failing routes, live error stream
• Traces Dashboard - Request traces with waterfall visualization

Access: http://localhost:3000/_crashless

🔍 Distributed Tracing

Automatic tracing for HTTP requests, fetch() calls, and fs.readFile() operations.

app.use(crashless({
  telemetry: {
    traces: {
      enabled: true,
      samplingRate: 0.2 // Sample 20% of requests
    }
  }
}));

Export traces: GET /traces.json?format=otlp - OpenTelemetry OTLP format

📈 OpenTelemetry Support

Full OpenTelemetry compatibility for metrics and traces.

app.use(crashless({
  telemetry: {
    engine: 'otel' // OpenTelemetry format
  }
}));

Endpoints:

• GET /metrics/otel - OpenTelemetry metrics
• GET /traces.json?format=otlp - OTLP trace export

📊 Prometheus Metrics

Prometheus-compatible metrics export for Grafana integration.

app.use(crashless({
  telemetry: {
    engine: 'prometheus'
  }
}));

Endpoint: GET /metrics - Prometheus format

🔌 Custom Exporters

Integrate with Sentry, Datadog, or any monitoring service.

app.use(crashless({
  exporters: [
    {
      name: 'sentry',
      onError: (error, metadata) => {
        Sentry.captureException(error, { extra: metadata });
      }
    },
    {
      name: 'datadog',
      onError: (error, metadata) => {
        datadogClient.sendError(error, metadata);
      }
    }
  ]
}));

⚡ Zero Dependencies

Uses only Node.js built-ins. No external npm dependencies.

🔐 Production-Safe

• Sensitive data masked automatically
• IP whitelist & token authentication
• Dashboard disabled in production by default
• Configurable overhead (2-30%)

---

🎯 Use Cases & Examples

Minimal Setup (Error Handling Only)

app.use(crashless({
  telemetry: { engine: 'none' }
}));

Overhead: ~3% | Use case: High-traffic apps needing only error handling

Standard Production

app.use(crashless({
  telemetry: { engine: 'builtin' }
}));

Overhead: ~20% | Use case: Standard production with metrics

Production + Observability

app.use(crashless({
  telemetry: {
    engine: 'builtin',
    traces: { enabled: true, samplingRate: 0.2 }
  }
}));

Overhead: ~27% | Use case: Full observability with distributed tracing

OpenTelemetry Integration

app.use(crashless({
  telemetry: {
    engine: 'otel',
    traces: { enabled: true }
  }
}));

Use case: Integration with OTel collectors (Jaeger, Tempo, etc.)

Prometheus + Grafana

app.use(crashless({
  telemetry: {
    engine: 'prometheus'
  }
}));

Use case: Prometheus scraping for Grafana dashboards

Custom Monitoring Integration

app.use(crashless({
  exporters: [
    {
      name: 'sentry',
      onError: (error, metadata) => Sentry.captureException(error)
    }
  ]
}));

Use case: Integration with existing monitoring tools

---

🎨 Dashboard Preview

System Overview

Route Performance

Error Analytics

Distributed Tracing (Waterfall View)

---

📊 Performance

Verified benchmarks (Node.js v24.3.0, M3 Pro, 50 concurrent users):

Configuration	Throughput (req/s)	Overhead
Plain Express	15,761	—
Crashless (minimal)	15,406	+2.3%
Crashless (+metrics)	13,082	+20.5%
Crashless (+traces 20%)	12,390	+27.2%
express-async-errors	6,919	+127.8%

Key Insight: Crashless is ~2.2× faster than express-async-errors with full observability.

Run benchmarks yourself →

---

⚖️ Comparison

Feature	Crashless	express-async-errors	APM Tools
Async error handling	✅	✅	⚠️ Config
Server crash prevention	✅	⚠️ Partial	⚠️ External
Built-in dashboard	✅	❌	✅ Remote
OpenTelemetry support	✅	❌	✅
Prometheus export	✅	❌	✅
Custom exporters	✅	❌	⚠️ Limited
Distributed tracing	✅	❌	✅
Zero dependencies	✅	❌	❌
Local metrics	✅	❌	⚠️ Cloud
Free & open source	✅	✅	❌
Avg overhead	~3-27%	~130%	~40-70%

---

💡 Why Crashless?

The Problem

// ❌ WITHOUT CRASHLESS - Server crashes
app.get('/users/:id', async (req, res) => {
  const user = await db.getUser(req.params.id); // 💥 Unhandled rejection = crash
  res.json(user);
});

The Solution

// ✅ WITH CRASHLESS - Server stays alive
app.use(crashless());

app.get('/users/:id', async (req, res) => {
  const user = await db.getUser(req.params.id); // 🛡️ Caught & logged
  res.json(user);
});

What You Get

• 🛡️ Automatic error handling - Never crash from unhandled errors
• 📊 Built-in dashboard - Real-time metrics, errors, and traces
• 🔍 Distributed tracing - See exactly what happens in every request
• 📈 OpenTelemetry - Full OTel compatibility
• 📊 Prometheus - Native Prometheus export
• 🔌 Custom exporters - Integrate with any monitoring tool
• 🔐 Production-safe - Sensitive data masked automatically
• ⚡ Zero npm dependencies - Uses only Node.js built-ins

---

🔗 Links

• 📦 npm Package
• 📚 Documentation
• 💻 GitHub Repository
• 🎮 Examples Repository
• 🖼️ Screenshots
• 🐛 Issues
• 💬 Discussions

---

📄 License

MIT © Sunny Ghodeswar

---

Production-ready observability without the complexity.

Get Started • Documentation • Try Demo