LIVEReal-time signals that become incidents

Production signals,
caught in real time.

Errors, slow requests, uptime checks, and deploys stream in live — then Errorgap correlates them into a single incident with a likely cause. So you're investigating, not piecing it together at 2am.

Free tier · 50k events/moNo credit cardSDKs for 16+ runtimes
LIVE · ox-coffee · productionrefreshing automatically
err
ActionView::Template::Errorapp/views/spree/home/index.haml:20
0.2s ago
err
ActiveRecord::RecordNotFoundapp/controllers/products_controller.rb:34
4s ago
warn
N+1 Query · Spree::Variantapp/views/spree/products/_card.html.erb:8
12s ago
err
NoMethodError · undefined `blah'lib/spree_core/helpers/base_helper.rb:70
38s ago
info
Deploy detected · v2.14.1CI · GitHub Actions
1m ago
warn
Slow request · 4823msPOST /checkout/payment
2m ago
err
Stripe::CardError · card_declinedapp/services/checkout/charge.rb:81
3m ago
info
Source maps uploadedreleases/api
4m ago
Trusted by teams at
How it works

From SDK to incident, automatically.

Install the SDK and ship. Errorgap captures and groups errors, correlates them with uptime, latency, and deploy signals, then assembles the evidence into an incident you can investigate.

01 · Install

Drop in the SDK

One package per runtime. Initialize with your project key and the SDK starts capturing — no manual try/catch plumbing required.

$ npm install @errorgap/sdk
+ added 1 package in 2s
$ npx errorgap init --key=prj_019df…
↻ configured · 16 routes instrumented
02 · Capture

We catch, group, dedupe

Exceptions are fingerprinted by stack signature and message — thousands of occurrences of one bug collapse into a single group with a count and a graph.

×4,212NoMethodError
03 · Correlate

Signals become an incident

A heuristic engine promotes elevated error rates, uptime failures, latency spikes, and deploy correlations into a first-class Incident.

Incident list showing correlated production incidents
04 · Investigate

Likely cause, in one place

A deterministic likely-cause panel, a confidence score, an evidence timeline, and an optional AI summary — everything to act, without tab-hopping.

Incident detail with confidence score and contributing signals
Incident Intelligence

When signals become an incident.

Errorgap's heuristic engine watches for six trigger conditions and assembles the evidence into one Incident object — instead of leaving it scattered across separate views.

Six heuristics · 60s cycle

One object. All the evidence.

High-volume error groups, uptime failures, error-rate spikes, latency anomalies, infrastructure saturation, and deploy correlations — when a condition fires, it becomes a first-class incident with a full evidence trail.

  • Six heuristics, evaluated on a 60-second cycle
  • Evidence timeline: error groups, releases, uptime checks, APM traces
  • Open → Acknowledged → Resolved lifecycle
  • Manual incidents for what the heuristics don't catch
Explore incidents →
Errorgap incident list with severity indicators, environment tags, and duration
AI Investigation

From signals to a likely cause, automatically.

The deterministic correlation panel runs the moment evidence loads — no configuration, no AI credit cost. It derives a likely cause, scores confidence, and surfaces the signals behind it. When you want prose, hit Summarize.

Deterministic first, AI on demand

A confidence score, not a guess.

Backtrace overlap, similar prior incidents, and time correlation feed a weighted confidence score from 10–90% — with the contributing signals shown. The AI summary is explicitly triggered, never automatic.

  • Backtrace overlap, similar incidents, time correlation
  • Confidence scored 10–90% with signal weights shown
  • Optional AI summary — explicit trigger, never automatic
  • MCP tools: explain_incident, find_likely_cause, propose_fix
See an investigation →
Incident detail showing confidence score, contributing signals, and the Summarize action
Built for the stack

Every signal, framed in context.

No screenshot pasting, no log-file digging. Errorgap connects the exception to the line, the line to the deploy, and the deploy to the person who can fix it — then watches availability and latency alongside.

Backtrace & Grouping

The line. The frame. The fix.

Every captured exception lands you on the offending source line with surrounding context and the full call stack. Same-signature errors collapse into one group with an occurrence count, sparkline, and the releases that triggered it.

  • Source maps for JS/TS, debug symbols for Go & Java
  • App / vendor / external frame filters
  • Fingerprint grouping, merge/split, regression detection
See a backtrace →
Errorgap backtrace view showing the highlighted source line, call stack, and fingerprint panel
Live logs

Watch your production breathe.

Stream errors, warnings, and structured logs straight from your runtime. Filter by level, source, or release — pause the stream, scrub backward, scrub forward.

  • WebSocket stream, sub-second latency
  • Per-environment views (production / staging / dev)
  • Aggregate view for capacity planning
Open the live stream →
Errorgap live log stream with per-level badges and timestamps
Uptime

Know when your users can't reach you.

HTTP, TCP, and ping checks sweep on configurable intervals. Status changes open incidents automatically, and the 90-day availability timeline shows every degraded window in context.

  • HTTP / TCP / ping · configurable intervals
  • SSL certificate expiry monitoring
  • Uptime incidents feed the Incident engine
See uptime monitoring →
Errorgap uptime page with monitor stats, response-time trends, and 90-day availability bars
Performance · APM

Slow routes surface before users file tickets.

Transaction timing from every web request and background job. Throughput, p95 latency, error rate, and DB time — with an Apdex score that tells you how users actually feel.

  • Web requests and background jobs, side by side
  • Apdex satisfaction with configurable threshold
  • Latency anomalies feed the Incident engine
See performance →
Errorgap performance page with Apdex, request rate, response time, and error rate
Session Replay

The session behind the failure.

Browser session timelines attach to incidents as evidence — DOM snapshots at the moment of failure, ranked most-relevant first.

  • Rage clicks, dead clicks, error events
  • Most-relevant sessions surfaced per incident
Infrastructure

CPU, memory, disk — per host.

Fleet-wide CPU, memory, and disk health with per-host, per-volume, and per-process breakdowns across every cluster.

  • Hosts, volumes, and processes views
  • Saturation signals feed the Incident engine
Deploy tracking

Tie every error to a release.

Record releases and Errorgap surfaces the first affected release for each error group — and correlates deploys with incidents.

  • First-affected-release per error group
  • Deploy correlation as an incident heuristic
AI-native

Give your AI agents production context.

Errorgap exposes a Model Context Protocol server so Claude, Cursor, Copilot, and any MCP-compatible agent can query live production data — error groups, incidents, backtraces, uptime status, and proposed fixes — without exposing your browser session.

claude_desktop_config.json
{
  "mcpServers": {
    "errorgap": {
      "url": "https://app.errorgap.com/mcp",
      "headers": {
        "Authorization": "Bearer egmcp_…"
      },
      "scopes": ["errors:read", "logs:read", "source:read"]
    }
  }
}
Errorgap Agent Access page — scoped MCP tokens with capabilities and expiry

Scoped, redacted, per project.

  • Tools: list/get errors, list/get incidents, explain incident, find likely cause, propose fix
  • Per-project exposure toggles — six categories of data
  • Org-level defaults with per-project overrides
  • Regex-based redaction rules with live preview
  • Scoped API keys, revocable from the Agent Access page
MCP tools
list_errorsget_errorlist_incidentsget_incidentexplain_incidentfind_likely_causepropose_fixuptime_status
Install

Three lines and you're shipping.

Pick your runtime. The SDK does the rest — async-safe, fork-safe, and zero overhead in dev.

// 1. Install $ npm install @errorgap/sdk // 2. Initialize once at boot import errorgap from '@errorgap/sdk' errorgap.init({ key: process.env.ERRORGAP_KEY, env: process.env.NODE_ENV, release: process.env.GIT_SHA, }) // 3. That's it. Capture a handled error: errorgap.capture(err, { user: req.user.id })
Integrations

Wired into the tools you already use.

Errorgap doesn't try to replace your issue tracker or your chat. It connects to them and stays out of the way.

GitHub
Auto-open issues
GitLab
Sync issue state
Slack
Channel routing
Jira
Ticket creation
Webhook
Custom endpoints
Pricing

Per-event pricing. No seat tax.

Pay for what you capture, not who's logged in. Every plan includes every feature except the bits genuinely tied to enterprise compliance.

Free
$0/mo
For solo devs and side projects.
50k events / mo
  • 7-day retention
  • 1 project
  • 200 replays · 1 uptime monitor
  • Email alerts
  • AI investigation
  • SSO
  • Audit log
Start free
Team★ POPULAR
$29/mo
For small teams shipping prod code.
500k events / mo
  • 30-day retention
  • Unlimited projects
  • 5k replays · 10 uptime monitors
  • AI investigation
  • Slack + GitHub
  • SSO
  • Audit log
Start trial
Business
$99/mo
For scaling orgs.
2M events / mo
  • 90-day retention
  • 25k replays · 50 uptime monitors
  • SSO · SAML
  • Audit log
  • Priority support · 4h SLA
Start trial
Enterprise
Custom
For regulated industries.
Unlimited events
  • Dedicated infrastructure
  • Custom data residency
  • Custom SLA
  • Security review
  • Solutions architect
Talk to sales

Close the errorgap.

Start free, no credit card. Turn scattered production signals into one investigable incident in under five minutes. Cancel anytime, keep your data.