# Coming from Sentry

> How Sentry's concepts and calls map to Sypnia's, what to remove from your code, and an honest list of what has no equivalent yet.

Applies to: the Sypnia engine (open source, self-hosted) and Sypnia Cloud (paid service). Status: at launch.  
Source: https://docs.sypnia.com/guides/coming-from-sentry/

This guide is for a team that uses Sentry on a web app and wants to try Sypnia, or move to it. It applies to Sypnia Cloud and to a self-hosted engine.

Sentry is excellent and broad. Sypnia is narrower on purpose: it is built to tell you in one sentence what is wrong, for whom and how to fix it, and to hand that to your coding agent. Some things Sentry does, Sypnia does not do, and this page says which.

**At the end you will have:** Sypnia running in your app, next to Sentry or instead of it, and a clear list of what you gain and what you give up.

## Run both first

Nothing in Sypnia's SDK conflicts with Sentry's. Both can listen for errors, both can add trace headers (they use different headers besides the standard `traceparent`), and each sends to its own address. Install Sypnia, compare the two for a week or two on real traffic, and remove Sentry when you are satisfied.

Two things to know while both run:

- Both record replays, so the page pays for two recorders. Turn replay off in one of them during the comparison.
- If you use Sentry's `tunnel` or a strict content security policy, add Sypnia's address too. See [Troubleshooting](https://docs.sypnia.com/sdks/troubleshooting).

## Concepts

| In Sentry                                      | In Sypnia                                                 | Difference                                                                                                               |
| ---------------------------------------------- | --------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------ |
| Organization, team, member                     | The same, on Sypnia Cloud only                            | The self-hosted engine has projects and tokens, no users.                                                                |
| Project                                        | Project                                                   | One per app. Frontend and backend of the same app share a project, so their traces connect.                              |
| DSN                                            | Ingest key (`spk_…`)                                      | Public and write-only, like a DSN. The address is separate: the option `endpoint`, only needed for a self-hosted engine. |
| Auth token                                     | API token (`sps_…`) with scopes `read`, `replay`, `admin` |                                                                                                                          |
| Environment                                    | Environment                                               | Alerts cover `production` only by default.                                                                               |
| Release                                        | Release                                                   | Use the short git commit.                                                                                                |
| Issue                                          | Problem                                                   | A problem is told as a sentence: what happened, to whom, since when, the likely cause.                                   |
| Event                                          | Occurrence of a problem                                   | In Sypnia, «event» means anything the SDK sends: a click, a page view, an error.                                         |
| Breadcrumbs                                    | The session's timeline                                    | Recorded without code: pages, clicks in words, requests, errors.                                                         |
| Session Replay                                 | Replay                                                    | Typed input is always masked, with no option to unmask.                                                                  |
| Tracing, spans                                 | Traces, spans                                             | Every request is traced; there is no trace sample rate.                                                                  |
| Web Vitals                                     | Performance                                               | With the element behind each value.                                                                                      |
| User Feedback, Crons, Profiling, Logs, Metrics | No equivalent                                             | See the last section.                                                                                                    |
| Seer, Autofix                                  | The agent, the prompt, MCP, pull requests                 | Pull requests are on Sypnia Cloud.                                                                                       |

## Code

### Browser

`src/main.ts`

```diff
- import * as Sentry from '@sentry/browser';
+ import { init } from '@sypnia/browser';

- Sentry.init({
-   dsn: 'https://abc123@o123456.ingest.sentry.io/7890123',
-   environment: 'production',
-   release: '4f2a91c',
-   integrations: [Sentry.browserTracingIntegration(), Sentry.replayIntegration()],
-   tracesSampleRate: 0.2,
-   replaysSessionSampleRate: 0.1,
-   replaysOnErrorSampleRate: 1.0,
- });
+ init({
+   project: 'spk_7d1f0c9e4b8a2f6d3c5e1a9b0f4d8c2e',
+   environment: 'production',
+   release: '4f2a91c',
+ });
```

There are no integrations to list and no sample rates in code: errors, clicks, requests, performance and replay are on by default, and the share of sessions recorded is a project setting (10 % by default, plus every session where something goes wrong).

| Sentry                                                 | Sypnia                                                                    | Notes                                                                                                                                            |
| ------------------------------------------------------ | ------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------ |
| `Sentry.init({ dsn })`                                 | `init({ project })`                                                       | [Every option](https://docs.sypnia.com/sdks/browser).                                                                                            |
| `Sentry.captureException(error)`                       | `reportError(error)`                                                      |                                                                                                                                                  |
| `Sentry.captureMessage(text)`                          | `track(name, props)`, or `reportError(new Error(text))`                   | A message that is not a failure is a custom event.                                                                                               |
| `Sentry.setUser({ id, email, username })`              | `identify({ person: { id, email, name } })`                               | Plus an optional `account`. `Sentry.setUser(null)` is `identify(null)`.                                                                          |
| `Sentry.addBreadcrumb(…)`                              | Usually nothing. `track(name, props)` for what Sypnia cannot see.         | Clicks, navigations and requests are already in the timeline.                                                                                    |
| `Sentry.setTag`, `setContext`, `setExtra`, `withScope` | No equivalent                                                             | See below.                                                                                                                                       |
| `beforeSend`                                           | `beforeSend`                                                              | Called for every event, not only errors.                                                                                                         |
| `ignoreErrors`                                         | `ignoreErrors`                                                            |                                                                                                                                                  |
| `denyUrls`, `allowUrls`                                | `appFrames`                                                               | Errors from scripts of other origins are dropped by default; `appFrames` names your CDN.                                                         |
| `tracePropagationTargets`                              | `traceTargets`                                                            | Your own origin is always included.                                                                                                              |
| `tunnel`                                               | `endpoint` set to a path on your own domain                               | You write the forwarding route.                                                                                                                  |
| `replayIntegration({ maskAllText, blockAllMedia })`    | `maskAllText`, `data-sypnia-mask`, `data-sypnia-block`                    | Page text is recorded as shown by default; typed input never is. If you relied on Sentry's default of masking all text, set `maskAllText: true`. |
| `Sentry.ErrorBoundary`                                 | Your own boundary that calls `reportError(error, { source: 'boundary' })` | [Example](https://docs.sypnia.com/sdks/browser).                                                                                                 |
| `Sentry.showReportDialog`                              | No equivalent                                                             |                                                                                                                                                  |

### Node

`src/instrument.ts`

```diff
- import * as Sentry from '@sentry/node';
+ import { init } from '@sypnia/node';

- Sentry.init({ dsn: process.env.SENTRY_DSN, tracesSampleRate: 0.2 });
+ init({ project: process.env.SYPNIA_PROJECT_KEY, service: 'shop-api' });
```

| Sentry                                      | Sypnia                                                           | Notes                                                                                                                          |
| ------------------------------------------- | ---------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------ |
| `Sentry.setupExpressErrorHandler(app)`      | One middleware that calls `reportError(error)` and `next(error)` | [Per framework](https://docs.sypnia.com/sdks/node).                                                                            |
| `Sentry.startSpan({ name }, fn)`            | `span(name, fn)`                                                 |                                                                                                                                |
| `Sentry.flush(ms)`, `Sentry.close(ms)`      | `flush(ms)`, `shutdown(ms)`                                      |                                                                                                                                |
| Automatic instrumentation of many libraries | `http`, `fetch`, `pg`, Supabase and PostgREST at launch          | For others use `span()`, or OpenTelemetry instrumentations with the [OTLP intake](https://docs.sypnia.com/sdks/opentelemetry). |

### Next.js

| Sentry                                                                   | Sypnia                                                                                |
| ------------------------------------------------------------------------ | ------------------------------------------------------------------------------------- |
| `withSentryConfig(nextConfig, options)`                                  | `withSypnia(nextConfig, options)`                                                     |
| `sentry.client.config.ts` / `instrumentation-client.ts`                  | `instrumentation-client.ts`, three lines                                              |
| `sentry.server.config.ts`, `sentry.edge.config.ts`, `instrumentation.ts` | `instrumentation.ts`, one line. The Edge runtime is not covered at launch.            |
| `global-error.tsx` with `Sentry.captureException`                        | The same file with `reportError(error, { source: 'boundary', digest: error.digest })` |
| `SENTRY_AUTH_TOKEN` at build                                             | `SYPNIA_API_TOKEN` at build                                                           |

The full setup is in [Next.js](https://docs.sypnia.com/sdks/nextjs).

### Source maps

`Build script`

```diff
- sentry-cli sourcemaps inject dist && sentry-cli sourcemaps upload --release "$RELEASE" dist
+ npx sypnia sourcemaps upload dist --release "$RELEASE" --delete-after
```

Sypnia does not inject ids into your files: it matches a stack frame to its map by the release and the file's path. Remove the bundler plugins (`@sentry/vite-plugin`, `@sentry/webpack-plugin`) when you remove Sentry. See [Source maps in CI](https://docs.sypnia.com/guides/source-maps-in-ci).

### Other backends

If your Python, Go, PHP, Rust or Java services report to Sentry with its SDKs, Sypnia's answer today is OpenTelemetry: add the OpenTelemetry SDK of the language and point its exporter at Sypnia. Native Sypnia SDKs for these languages are **\[Planned]**. See [OpenTelemetry](https://docs.sypnia.com/sdks/opentelemetry).

## What to remove, when you are done

1. The packages: `@sentry/browser`, `@sentry/react`, `@sentry/node`, `@sentry/nextjs`, the bundler plugins, `@sentry/cli`.
2. Every `Sentry.` call. Most disappear rather than being replaced: `addBreadcrumb`, `setTag`, `setContext`, the integrations list.
3. The config files `sentry.*.config.ts` and `.sentryclirc`, and `withSentryConfig`.
4. The variables `SENTRY_DSN`, `SENTRY_AUTH_TOKEN`, `SENTRY_ORG`, `SENTRY_PROJECT` from your host and CI.
5. Sentry's hosts from your content security policy, and the `tunnel` route if you had one.

## What has no equivalent yet

Said plainly, so you can decide:

| In Sentry                                                                 | In Sypnia                                                                                                                                                                                                                                                  |
| ------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Tags, contexts, extra data and scopes on an error                         | Not at launch. An error carries its session, person, account, release, route and trace. Put your own facts in a `track()` event next to it, or change the event in `beforeSend`.                                                                           |
| Search and saved views over arbitrary tags; Discover; dashboards          | Not at launch. Custom metrics and dashboards are **\[Planned]**.                                                                                                                                                                                           |
| Native SDKs: iOS, Android, React Native, Flutter, Unity, desktop          | **\[Planned]** for iOS and Android. Web views work with the browser SDK.                                                                                                                                                                                   |
| SDKs for Python, PHP, Go, Rust, Ruby, Java, .NET                          | **\[Planned]** for Python, PHP, Go and Rust. Today: OpenTelemetry traces.                                                                                                                                                                                  |
| Logs                                                                      | **\[Planned]**                                                                                                                                                                                                                                             |
| Profiling                                                                 | No.                                                                                                                                                                                                                                                        |
| Cron monitoring                                                           | No. Uptime checks tell you a URL stopped answering, not that a job did not run.                                                                                                                                                                            |
| User feedback widget                                                      | No.                                                                                                                                                                                                                                                        |
| Attachments, minidumps, native crash symbolication                        | No.                                                                                                                                                                                                                                                        |
| Trace sampling in the SDK                                                 | No: every request is traced. Use `ignoreRoutes` to leave routes out; sampling of successful requests is **\[Planned]**.                                                                                                                                    |
| Alert rules with many conditions; integrations with chat and ticket tools | Sypnia has a fixed set of alerts with thresholds you can tune. They arrive by e-mail and in the app on Sypnia Cloud, and by webhook on any engine. There are no chat or ticket integrations: build on the [webhook](https://docs.sypnia.com/api/webhooks). |
| Issue assignment, ownership rules, code owners                            | No. A problem is open, resolved or ignored.                                                                                                                                                                                                                |
| Single sign-on                                                            | **\[Planned]**                                                                                                                                                                                                                                             |
| Importing your history from Sentry                                        | No. Sypnia starts from the day you install it.                                                                                                                                                                                                             |

What you get in exchange is on [What Sypnia is](https://docs.sypnia.com/start/what-sypnia-is): problems as sentences, the element behind slow pages, rage and dead clicks, and the fix handed to your coding agent as a prompt, through MCP, or as a pull request.

The whole list of what is planned, without dates, is in [Planned](https://docs.sypnia.com/reference/planned).
