Sentry

Error tracking first: SDKs in your app catch exceptions with their stack traces and send them to Sentry, which groups them into issues; tracing, logs and session replay sit on top.

What it is: Error tracking
Used for: Distributed tracing,Logs,Observability
Type: Commercial product
Made by: Functional Software, Inc. (Sentry)
License: FSL-1.1-Apache-2.0: source-available, each release becomes Apache 2.0 after two years (BSL 1.1 from 2019, BSD 3-Clause before); SDKs are MIT
Facts checked: 5 October 2026

What it is

You add a Sentry SDK to each app and give it a DSN, a URL that names your project. When code throws, the SDK captures the exception with its stack trace, the breadcrumbs that led up to it (recent HTTP requests, log lines, database queries, clicks) and context such as release, environment and user. Sentry computes a fingerprint for each event, from the app’s own stack frames, else the exception type and value, else the message, and events with the same fingerprint become one issue, so a crash that happens 10,000 times is one line with a count. Uploaded source maps and debug symbols turn minified JavaScript and native crashes back into readable file names and line numbers. The same SDKs record performance traces as spans. In browsers they can also record session replays from DOM changes rather than video, masking text and inputs by default; mobile SDKs offer replay too.

Most teams use the hosted service at sentry.io, billed by volume: the free Developer plan includes 5,000 errors a month for one user, and Team ($26 a month) and Business ($80) include 50,000 errors, 5 million spans, 50 replays and 5 GB of logs, with reserved or pay-as-you-go volume beyond that. The server is also on GitHub and can be self-hosted with Docker Compose, which brings up Kafka, ClickHouse, PostgreSQL, Redis, Relay, Snuba and Symbolicator on one machine. Its Functional Source License allows any use except offering a competing product; it is not an OSI open-source licence, so this page lists Sentry as a vendor product.

Why teams pick it

Grouping by fingerprint turns a flood of exceptions into a short list of issues, each with a count of events, and custom fingerprint rules when the default grouping is wrong
Stack traces you can read: source maps for minified JavaScript and symbolication for native and mobile crashes
SDKs for most languages and frameworks, MIT licensed, with breadcrumbs and request context captured automatically
Releases tie issues to deploys and commits, so a regression points at the release that introduced it
Self-hosting is possible: the same server code, free for internal use, with releases turning Apache 2.0 after two years

Watch out for

Not open source in the OSI sense: the FSL forbids offering Sentry as a competing service, and only two-year-old releases become Apache 2.0
Self-hosted Sentry is heavy: at least 4 CPU cores and 16 GB of RAM plus 16 GB of swap, dozens of containers, and no guarantees or dedicated support
Billing per event: when reserved volume and the pay-as-you-go budget run out, new events are dropped until the next cycle, so a noisy bug can blind you to the rest
Built around application code: logs and metrics are newer additions billed per GB beyond 5 GB, and OTLP ingest is in open beta and doesn’t accept OTLP metrics
No on-call scheduling or status pages; alerts go out to tools such as PagerDuty or Slack

How it fits with other technologies

What Sentry uses

What uses Sentry

Better Stackaccepts error events from the SDKs ofSentryObservability

Errors, breadcrumbs and a span from a Python service · python

# pip install sentry-sdk
import sentry_sdk

sentry_sdk.init(
    dsn="https://<key>@o<orgId>.ingest.sentry.io/<projectId>",
    environment="production",
    release="checkout@2.4.1",      # ties issues to a deploy
    traces_sample_rate=0.1,         # keep 10% of traces: spans are billed
    send_default_pii=False,
)

def charge(order):
    sentry_sdk.set_tag("plan", order.plan)
    sentry_sdk.add_breadcrumb(category="payment", message=f"charging order {order.id}", level="info")
    with sentry_sdk.start_span(op="payment.charge", name="charge card"):
        try:
            return gateway.charge(order.total)
        except gateway.CardDeclined:
            return None                 # expected: not reported
        # anything else propagates; the SDK reports it with stack trace and breadcrumbs

Hosted plans#

List prices from sentry.io, checked 5 October 2026. Every plan meters the same units; paid plans add users, features and room to buy more volume.

Included each month	Developer	Team	Business
Price	$0, one user	$26 a month	$80 a month
Errors	5,000	50,000	50,000
Tracing spans	5 million	5 million	5 million
Session replays	50	50	50
Logs	5 GB	5 GB	5 GB
Uptime and cron monitors	1 each	1 each	1 each

Extra volume is reserved in advance at a discount or drawn from a pay-as-you-go budget: about $0.00012 to $0.00036 per error, $0.0000016 to $0.000004 per span, and $0.50 per GB of logs, cheaper per unit at higher volumes.
Enterprise pricing is by quote.

How the licence changed#

Sentry has always published its server code, but under three different licences.

BSD 3-Clause

2008 to 2019

A permissive open-source licence, last used by Sentry 9.1.2 in July 2019. Anyone could run it, change it or sell it as a hosted service.

Business Source License 1.1

from Sentry 10, 2019

Switched on 6 November 2019 and first shipped in Sentry 10.0.0 (January 2020). Free to use except as a commercial “Application Monitoring Service”; each version became Apache 2.0 after 36 months.

Functional Source License

from 23.11.1, 2023

Sentry wrote the FSL and adopted it on 17 November 2023, moving to FSL 1.1 in February 2024. It allows any use except a competing product or service, and each release becomes Apache 2.0 after two years.

See it in a real stack

No architecture uses Sentry yet. Drop it into the playground and wire it up yourself.Open playground →

Where it came from2008–2023

In 2008 David Cramer was building Django sites, and Django’s answer to an unhandled error was to send an email for every one. On a busy site that meant inboxes full of copies of the same crash. On 12 May 2008 he made the first commit of djangodblog, “Django DB Error Logging”, which stored exceptions in the database and showed them in aggregate instead.

The project was renamed django-sentry in 2010 and plain sentry in 2012 as it grew beyond Django, first to the rest of Python and then, as contributors moved to companies using other languages, to Ruby, JavaScript and many more. Spinning out a hosted service, now sentry.io, let the team put real money into the project, and by 2018 the company had about 70 employees and raised a $16 million Series B.

Sentry also became known for its licences. In 2019 it left BSD for the Business Source License, after funded competitors copied its work, and in 2023 it wrote its own Functional Source License, then promoted “Fair Source” in 2024 as a name for code that is public but protects its maker’s business for a limited time.

Why it’s built this way

Aggregate errors instead of emailing each one: High-traffic Django sites sent the same error email thousands of times. Storing exceptions and grouping identical ones, ranked by how often they happen, made the noise usable.
Capture context, not just the message: Stack locals, request data and later breadcrumbs let a developer see the state that caused an error without reproducing it.
Public code with a delayed open-source licence: Cramer wrote in 2019 that a fully permissive licence let competitors copy Sentry and resell it. The BSL, and later the FSL, keep the code readable and free to run while blocking competing hosted services, and turn each release permissive after a delay.

Timeline

2008
First commit of djangodblog on 12 May
2010
Released as django-sentry
2012
Becomes plain sentry, no longer Django-only
2019
Relicensed from BSD to the Business Source License in November
2022
Acquires Codecov
2023
Switches to its own Functional Source License in November

Sources28 · facts checked 5 October 2026

Improve this page on GitHub