Skip to content
Published on

Error Tracking & Monitoring 2026 — Sentry / Bugsnag / Honeybadger / GlitchTip / Highlight / LogRocket / Hyperdx Deep Dive

🇰🇷KO🇺🇸EN🇯🇵JA
Split View필사 모드
Authors

1. The 2026 Error Tracking Map — Commercial / Open Source / Session Replay

The "just use Sentry" era is over in 2026. Sentry is still the de-facto leader, but three clear categories now surround it — classic commercial tools, self-hostable open source, and a session replay camp that shows you the 60 seconds of user behavior right before the error.

The big picture looks like this.

  • Commercial error tracking — Sentry (Codecov acquisition 2024, AI features expanded), Bugsnag (SmartBear acquired 2021, enterprise), Honeybadger (indie-friendly), Rollbar (long tail), Raygun (legacy .NET / mobile friendly)
  • Open source error tracking — GlitchTip (Sentry SDK-compatible), Highlight.io (session replay + errors), Hyperdx (OpenTelemetry-native), Sentry self-hosted (Business Source License)
  • Elixir/Ruby specialist — AppSignal (Elixir first, also Ruby/Node/Python)
  • Logs + errors + status pages bundle — BetterStack (the merger of Better Uptime + Logtail)
  • Session replay first — LogRocket (product analytics + errors), FullStory (UX analytics leader), OpenReplay (open source)
  • APM-integrated — Datadog Error Tracking, New Relic Errors Inbox
  • Standards — OpenTelemetry Logs/Errors signal, W3C trace context

Three shifts define 2026. First, Sentry's 2024 Codecov acquisition closed the loop from "error → impacted code → impacted PR → whose change" inside one company. Second, the OpenTelemetry Logs signal is now in its second year of GA, making vendor-neutral error pipelines practical. Third, AI grouping and AI triage are now standard features at Sentry, Datadog, and Bugsnag.

This guide walks through all of these tools at May 2026 in terms of features, pricing, self-hosting, and data residency.

2. Sentry — Leader, Codecov Acquisition (2024), AI Features

Sentry started in 2008 as an open source error tracker by David Cramer and is now the de-facto standard. The biggest 2024 event was the Codecov acquisition — by buying the code coverage tool, Sentry can now show test coverage at the error's line and the PR number that introduced the bug in the same screen.

As of May 2026 Sentry covers the following areas.

  • Error Monitoring — JS/Node/Python/Ruby/Go/Java/.NET/mobile in every major runtime
  • Performance Monitoring — transactions and distributed tracing
  • Session Replay — DOM replay of the N seconds before an error (with masking)
  • Profiling — CPU profiling (extended to Continuous Profiling)
  • Cron Monitoring — alerts when a scheduled job doesn't run
  • Crons / Uptime — health checks for external endpoints
  • User Feedback — collect user comments from the error page
  • Sentry AI — automated grouping, root cause guess, Autofix PR suggestion
  • Codecov integration — coverage at impacted lines

A JavaScript client setup looks like this.

import * as Sentry from '@sentry/nextjs'

Sentry.init({
  dsn: process.env.NEXT_PUBLIC_SENTRY_DSN,
  release: process.env.SENTRY_RELEASE,
  environment: process.env.NODE_ENV,
  tracesSampleRate: 0.1,
  replaysSessionSampleRate: 0.0,
  replaysOnErrorSampleRate: 1.0,
  integrations: [
    Sentry.replayIntegration({
      maskAllText: true,
      blockAllMedia: true,
    }),
  ],
})

A few core patterns.

  • Release tracking — put a git SHA or semantic version in release and upload source maps
  • Environment separation — environment: 'production' | 'staging' | 'development'
  • Sampling — tracesSampleRate for cost control (0.1 = 10%)
  • Replay — 0% by default, 100% only on error sessions
  • PII masking — maskAllText, strip tokens in a beforeSend hook

Pricing as of May 2026 starts at Team 26/monthandBusiness26/month and Business 80/month. Self-hosting is supported, but since 2024 the Sentry main repo is under Business Source License (BSL) — you can't resell as a hosting service, but internal company use is free.

3. Bugsnag (SmartBear) — Enterprise

Bugsnag started in 2013 and was acquired by SmartBear in 2021. SmartBear owns a QA toolchain (BitBar / Cucumber / SoapUI / TestComplete), and since the acquisition Bugsnag has leaned harder into enterprise, compliance, and SDLC integration.

Bugsnag's differentiators.

  • Application Stability Score — "the fraction of sessions that ended without errors" front and center. Natural for SLO management
  • Release Stages — staging / production separation is first-class
  • Error Inbox workflow — Open / Snoozed / Fixed / Ignored state machine
  • Mobile first — iOS / Android / Unity / React Native / Flutter all top tier
  • Data residency — EU / US host options (for GDPR / compliance)
  • SAML SSO, SCIM, audit logs as standard

Bugsnag has less share in the Korean / Japanese market than Sentry, but is still a top pick at global enterprises (especially mobile games and fintech).

Pricing is not public — it's sales-led. Typically a mix of per-seat and per-event billing.

The JavaScript client setup looks almost identical to Sentry.

import Bugsnag from '@bugsnag/js'
import BugsnagPluginReact from '@bugsnag/plugin-react'

Bugsnag.start({
  apiKey: process.env.NEXT_PUBLIC_BUGSNAG_KEY,
  appVersion: process.env.APP_VERSION,
  releaseStage: process.env.NODE_ENV,
  enabledReleaseStages: ['production', 'staging'],
  plugins: [new BugsnagPluginReact()],
})

4. Honeybadger — Indie-Friendly

Honeybadger was started in 2012 by Ben Curtis, Joshua Wood, and Starr Horne as a bootstrapped company. They run without VC capital and have kept the "indie hacker / Rails community friend" positioning.

Highlights.

  • Error tracking + Uptime Monitoring + Check-ins (cron monitoring) + Insights (logging) in one plan
  • Strong in full-stack frameworks — Ruby on Rails / Django / Laravel / Phoenix
  • Single-developer free tier — fits personal side projects
  • Pricing is simple and public — Solo 26/month,SmallTeam26/month, Small Team 79/month, Production $199/month
  • The top choice for indie / bootstrap / small SaaS companies
  • Data residency is US-centric

Honeybadger's appeal is "you can use it without burden even if your team is small, your billing is simple, and your compliance is light." It's the choice for solo or small teams who find Sentry's feature breadth heavy or Bugsnag's sales cycle too long.

Ruby setup is basically one line.

# Gemfile
gem "honeybadger"

# config/honeybadger.yml
api_key: 'xxx'
env: <%= Rails.env %>

5. Rollbar — Long Tail

Rollbar was started in 2012, around the same time as Sentry. It used to be the other half of a duopoly with Sentry, but in the 2020s lost ground on feature breadth, community, and pricing. It's still alive in 2026 but in a "long tail" position.

Rollbar's remaining strengths.

  • RQL (Rollbar Query Language) — SQL-like queries on your error data
  • Automation Rules — rule-based auto classification and escalation
  • Telemetry — pre-error user behavior recording (similar to Sentry breadcrumbs)
  • Stable SDKs — 10+ years of maintenance
  • Pricing — Essentials 21/month,Advanced21/month, Advanced 83/month, Enterprise sales

Existing Rollbar users have no reason to leave, but cases where Rollbar is the first pick for new adoption have shrunk.

6. GlitchTip — Open Source Sentry-Compatible

GlitchTip started in 2020 at Burke Software as an open source error tracker. Its biggest feature is wire-protocol compatibility with the Sentry SDK — you change the DSN on the client and the same code reports to GlitchTip.

GlitchTip's target slot is clear.

  • "Fully open source (MIT) and self-hostable" — both before and after Sentry's BSL switch
  • A minimal error tracking option for small companies, nonprofits, schools, and security-sensitive environments
  • Features focus on ~30% of Sentry (error tracking / alerting / releases / source maps)
  • A hosted SaaS is also offered — from $15/month with a "Pay what you can" option

One-line self-hosting with Docker Compose.

git clone https://gitlab.com/glitchtip/glitchtip-backend.git
cd glitchtip-backend
docker compose up -d

Just change the DSN on an existing Sentry client.

import * as Sentry from '@sentry/browser'

Sentry.init({
  // Point at GlitchTip instead of Sentry
  dsn: 'https://yourkey@glitchtip.example.com/1',
})

GlitchTip doesn't chase every Sentry feature (no Performance / Replay / Profiling). But for "we just want errors caught well, and we want it running in our own datacenter," it's the lightest answer.

7. Highlight.io — Open Source + Session Replay

Highlight.io is an open source observability platform started in 2022. Its defining feature is bundling error tracking + session replay + logs + distributed tracing on one screen. Apache 2.0 licensed, GitHub-first, self-hosting prioritized.

Highlights.

  • Session replay — DOM / console / network replay of the N minutes before an error
  • Error tracking — Sentry-like grouping and alerting
  • Logs — ClickHouse backend, fast search
  • OpenTelemetry compatible — accepts OTLP traces
  • Hosted SaaS + self-hosted both available
  • Simple pricing — Free 10k sessions/month, pay-as-you-go above

What makes Highlight interesting is "open source but with LogRocket-style session replay." It's a good fit for indies, small teams, or nonprofits where LogRocket's licensing or pricing is too heavy.

import { H } from 'highlight.run'

H.init('YOUR_PROJECT_ID', {
  environment: 'production',
  version: 'commit:abcdefg12345',
  tracingOrigins: true,
  networkRecording: {
    enabled: true,
    recordHeadersAndBody: true,
    urlBlocklist: ['/api/auth/login'],
  },
})

8. AppSignal — Elixir/Ruby Specialist

AppSignal is a Dutch company that started in 2012 as a Ruby on Rails APM and now first-class supports Elixir / Node.js / Python / Ruby as a full-stack observability tool. In the Elixir community it's basically the standard.

Highlights.

  • APM + errors + logs + host metrics + alerts all in one plan
  • Elixir / Phoenix / LiveView first class — the library is written by an Elixir team
  • Ruby on Rails / Sidekiq / Hanami also first class
  • Simple pricing — from $19/month at 2.5M requests/month
  • Data residency — EU (Netherlands) host option (GDPR-friendly)
  • Solid classic APM features — Apdex, host monitoring

AppSignal is the top pick for "I use Elixir / Rails-style dynamic languages and want APM + errors in a single tool." It's a poor fit for teams whose main stack is JS / Java / Go.

Elixir setup.

# mix.exs
defp deps do
  [
    {:appsignal_phoenix, "~> 2.4"}
  ]
end

9. BetterStack — Logs + Errors + Status Pages

BetterStack is a Slovak company that merged Better Uptime (2021) and Logtail (2022) into an observability platform. As of 2026 it bundles Uptime / Logs / Telemetry (metrics+tracing) / Incidents / Status Pages in one SaaS.

Highlights.

  • Simple pricing — Uptime free, Logs from $25/month
  • ClickHouse backend — second-grain log search
  • Status Pages are first class — auto-publish on incident
  • Incident management — on-call / escalation / rules
  • OpenTelemetry compatible — OTLP log ingestion
  • Slack / Discord / Microsoft Teams alerting first class

BetterStack's differentiator is "one company that bundles Uptime + Logs + Status Page." A good starting point for small SaaS / indie / startup teams who don't want to glue PagerDuty + Datadog + statuspage.io together.

It's not a "dedicated" error tracker, but log-based error detection and alerting is solid. There's partial overlap with Sentry's territory.

10. LogRocket / FullStory / OpenReplay — Session Replay

Session replay shows the user's screen / clicks / network / console as a video for the N minutes before an error. It solves the classic "bug doesn't reproduce" problem. The 2026 top three are LogRocket, FullStory, and OpenReplay.

LogRocket — started in 2016, the best-known session replay tool

  • Bundles error tracking + session replay + product analytics (funnels / retention)
  • React / Vue / Angular SDKs all first class
  • Galileo AI — auto-summarize sessions, auto-detect where users got stuck
  • Pricing is sales-led, generally per-session billing
  • Data residency — US / EU options

FullStory — the UX analytics leader

  • Click maps / heatmaps / frustration signals (rage click, dead click) auto-detected
  • Stronger on product analytics / marketing analytics
  • Error tracking is secondary — usually combined with another tool
  • Enterprise pricing, sales-led

OpenReplay — open source session replay (Elastic License)

  • The top self-hosting pick — Kubernetes Helm chart available
  • Bundles error tracking + session replay + backend tracing
  • Hosted SaaS too — 1k sessions/month free
  • PII masking first class — masking on the client before transport

Session replay always brings PII and GDPR concerns. Masking input values / credit card numbers / tokens on the client before transport is standard.

// LogRocket example
import LogRocket from 'logrocket'

LogRocket.init('your/app-id', {
  network: {
    requestSanitizer: (request) => {
      if (request.url.includes('/api/auth')) return null
      delete request.headers['Authorization']
      return request
    },
  },
  dom: {
    inputSanitizer: true,
    textSanitizer: false,
  },
})

11. Hyperdx — OpenTelemetry-Native Open Source

Hyperdx is an open source observability platform started in 2023. Its defining feature is being OpenTelemetry native — OTLP is the first-class input and ClickHouse is the backend. After ClickHouse acquired Hyperdx in 2024, it sits as one component of ClickHouse Observability.

Highlights.

  • OpenTelemetry / OTLP first class — usable with only the OTel SDK, no proprietary SDK
  • ClickHouse backend — petabyte-scale searchable
  • Logs + traces + metrics + session replay + RUM in one screen
  • Apache 2.0 open source — self-host freely
  • Hosted SaaS also available
  • Pricing (SaaS) — data-volume based, unlimited users

Hyperdx's slot is clear. It's for teams that want "no vendor lock-in on top of OpenTelemetry standards, self-hosted, with a Sentry-like UX." After the ClickHouse acquisition, the "ClickHouse + Hyperdx + OTel" stack is a strong alternative to Datadog / New Relic.

// Just configure the OpenTelemetry SDK and it ships to Hyperdx
import { NodeSDK } from '@opentelemetry/sdk-node'
import { OTLPTraceExporter } from '@opentelemetry/exporter-trace-otlp-http'

const sdk = new NodeSDK({
  traceExporter: new OTLPTraceExporter({
    url: 'https://in-otel.hyperdx.io/v1/traces',
    headers: {
      authorization: process.env.HYPERDX_API_KEY,
    },
  }),
})

sdk.start()

12. Datadog / New Relic — Integrated with APM

Datadog Error Tracking and New Relic Errors Inbox are "error tracking built into APM." Not a separate tool — a tab inside APM.

Datadog Error Tracking highlights.

  • Auto-linked to APM transactions by trace_id
  • Auto-linked to RUM (Real User Monitoring) session replay
  • Watchdog AI — auto-detection of anomalous error spikes
  • Pricing — APM $31/month per host + Error Tracking billed separately
  • First-class SDKs for every language / runtime

New Relic Errors Inbox highlights.

  • 2024 pricing model simplified — per-user + data-volume based
  • APM + Browser + Mobile + Synthetic errors in one screen
  • Codestream integration — view errors directly from the IDE
  • Free tier — 100GB/month, 1 user free

For teams "already on Datadog / New Relic as APM," it makes sense to turn this on before adopting Sentry separately. APM + errors in one screen, no extra tool.

13. Maturity of the OpenTelemetry Logs/Errors Signal

OpenTelemetry was formed in 2019 by merging OpenTracing and OpenCensus as the observability standard. Initially only Traces was GA — Metrics went GA in 2023 and Logs in 2024. As of 2026, the scenario "send logs + traces + metrics + errors with one OpenTelemetry SDK and swap backends behind it" is practical.

The standard shape for sending errors via OpenTelemetry.

  • Mark the span status as ERROR (span.setStatus({ code: SpanStatusCode.ERROR }))
  • Record the exception as a span event (span.recordException(err))
  • Or ship via the Logs signal and link by trace_id
import { trace, SpanStatusCode } from '@opentelemetry/api'

const tracer = trace.getTracer('my-app')

async function fetchUser(id: string) {
  return tracer.startActiveSpan('fetchUser', async (span) => {
    try {
      const user = await db.user.findUnique({ where: { id } })
      span.end()
      return user
    } catch (err) {
      span.recordException(err)
      span.setStatus({ code: SpanStatusCode.ERROR, message: err.message })
      span.end()
      throw err
    }
  })
}

Errors produced this way can be sent anywhere via OTLP — Sentry (OTLP input beta), Datadog, New Relic, Hyperdx, Grafana, or your own backend. That's the foundation of the 2026 "errors are standard, vendors are swappable" scenario.

In practice not every vendor accepts OTLP as first class. Sentry / Datadog / New Relic all give their own SDKs more features (auto-context / auto-grouping / auto-PII masking), and the OTLP path is leaner. There's a trade-off between "vendor lock-in" and "maximum features."

14. Korea / Japan — Toss, Kakao, Mercari, LINE, freee

A look at what large Korean and Japanese companies actually use for error tracking shows the global trend with some regional color.

Korean cases

  • Toss — Public use of Sentry. Mentioned in their engineering blog and conferences. Both mobile and web
  • Kakao — Mix of in-house tools and Sentry. Some services use an in-house error tracker, others use Sentry. The in-house share is large due to cost and data residency at scale
  • Naver — In-house corporate tools dominate. Some subsidiaries and new projects use Sentry
  • Woowa Brothers (Baemin) — Public use of Sentry. Both backend and frontend
  • Daangn — Public use of Sentry
  • LINE Plus (LINE Korea) — Same in-house tools as LINE proper
  • 11st / Coupang — Heavier use of integrated Datadog / New Relic

Japanese cases

  • Mercari — Public use of Sentry. Mobile (iOS / Android) first
  • LINE — In-house corporate tools (LINE Observability) as the core. Some subsidiaries use Datadog
  • freee (accounting SaaS) — Public use of Sentry. Some Bugsnag usage too
  • CyberAgent — Mix of Sentry + Datadog
  • pixiv — Public use of Sentry
  • Rakuten — Mix of in-house tools + Sentry
  • DeNA / GREE — Large in-house tool share

A common pattern emerges. Once user data volume crosses a certain threshold (hundreds of millions of events per month), teams revisit in-house tools or self-hosting. Cost matters, but the data residency requirements of Korea's Personal Information Protection Act and Japan's APPI matter more. So small companies tend toward Sentry SaaS while large ones split into Sentry self-hosted or in-house tools.

15. Who Should Pick What — Solo / Startup / Enterprise / Self-Hosted

Finally, recommendations by scenario.

Solo / indie / side project

  • Sentry Developer (free) or Honeybadger Solo $26/month
  • BetterStack for Uptime + Status Page (start free)
  • If you can take the self-hosting burden, GlitchTip's hosted SaaS

Small startup (10 people or less)

  • Sentry Team $26/month — the top pick for almost every scenario
  • Or Honeybadger Small Team $79/month (if Rails / Phoenix is the main stack)
  • If session replay matters, add Highlight.io or LogRocket
  • If already on Datadog, use Datadog Error Tracking

Growth-stage startup (10–100 people)

  • Sentry Business $80/month — Replay / Profiling / unlimited users
  • Or Bugsnag — mobile games / fintech with compliance focus
  • BetterStack — Uptime + Status Page + Incidents bundle
  • Send via OpenTelemetry SDK and run a backend like Sentry / Datadog

Enterprise (100+, compliance matters)

  • Sentry Enterprise — SAML / SCIM / data residency / audit
  • Or Bugsnag (SmartBear) — SAML / SCIM / SOC 2 / GDPR / HIPAA
  • Or Datadog / New Relic — as part of APM
  • At scale, Sentry self-hosted or in-house tools

Self-hosted / data sovereignty

  • Minimal — GlitchTip (MIT)
  • Full stack — Highlight.io or Hyperdx (both Apache 2.0)
  • Sentry self-hosted (BSL) — internal company use is free
  • OpenTelemetry + ClickHouse + Hyperdx — minimize vendor lock-in

Language / runtime priorities

  • JavaScript / TypeScript — Sentry, Highlight.io, LogRocket
  • Python / Django — Sentry, GlitchTip
  • Ruby / Rails — Sentry, Honeybadger, AppSignal
  • Elixir / Phoenix — AppSignal first, Sentry second
  • iOS / Android — Sentry, Bugsnag
  • Go — Sentry, Hyperdx (OTel)
  • Java / Spring — Sentry, Datadog APM
  • .NET — Sentry, Raygun

The best 2026 setup is one of two — "Sentry" or "OpenTelemetry + backend." Sentry gives immediate value; OpenTelemetry gives long-term freedom. Small teams choose Sentry, larger teams layer Sentry / Datadog / Hyperdx on top of OTel — a two-sided strategy that has become common.

16. References

Sentry

Bugsnag

Honeybadger

Rollbar

GlitchTip

Highlight.io

AppSignal

Raygun

BetterStack

LogRocket / FullStory / OpenReplay

Hyperdx

Datadog / New Relic

OpenTelemetry

Korea / Japan engineering blogs

Discuss on Twitter • View on GitHub