Skip to content
bucker

Keep Sentry, add Bucker

Evaluating Bucker does not mean removing Sentry. A dual-send transport wraps your Sentry SDK's own transport so every envelope goes to Sentry as it does today and to Bucker, under the same event_id. Each side then links to the other, and when you are ready to switch the change is one DSN.

What it does

  • Sentry first, never delayed. Your Sentry transport is called exactly as before and its result is the one the Sentry SDK sees. Bucker's send happens beside it, from a bounded queue.
  • Failures are isolated both ways. If Bucker is down, slow or rate limiting you, the Sentry send is not affected and nothing is raised into your code. If Sentry fails, Bucker's copy is still sent and the Sentry error still surfaces as it would have.
  • Bounded and counted. At most 30 Bucker envelopes wait at once (errors outlive everything else), each request times out at 5 seconds, nothing is retried, and a 429 drops rather than queues. Every drop is counted by reason.
  • Two links on the shared event id. The Sentry copy gains a bucker.event_url tag (only if you give the wrapper a URL builder), and Bucker stores a link to the Sentry event on the issue (only if you give it the Sentry URL builder). Neither needs credentials.
  • Consent and masking apply to the Bucker copy only. transformForBucker runs on Bucker's copy; return null to send nothing to Bucker for that envelope.

Bucker keeps the full envelope, traces, sessions and attachments included, which is what a Sentry-intake-only integration drops.

JavaScript

import * as Sentry from '@sentry/browser'
import { dualSend } from '@bucker/sdk-core/dual-send'

Sentry.init({
  dsn: SENTRY_DSN,
  transport: dualSend(Sentry.makeFetchTransport, {
    dsn: BUCKER_DSN,
    buckerEventUrl: (id) => `https://app.bucker.io/search?event=${id}`,
    sentryEventUrl: (id) => `https://sentry.io/organizations/<your-org>/issues/?query=${id}`,
  }),
})

It ships as its own entry, @bucker/sdk-core/dual-send, and is not in the root bundle, so the browser size budget of @bucker/sdk-core is unchanged.

Python

import sentry_sdk
from sentry_sdk.transport import HttpTransport
from bucker_sdk.dual_send import DualSendTransport

sentry_sdk.init(
    dsn=SENTRY_DSN,
    transport=lambda options: DualSendTransport(
        HttpTransport(options),
        BUCKER_DSN,
        bucker_event_url=lambda eid: f"https://app.bucker.io/search?event={eid}",
        sentry_event_url=lambda eid: f"https://sentry.io/organizations/<your-org>/issues/?query={eid}",
    ),
)

Python's Sentry transport hands envelopes to its own worker thread, so "sent to Sentry" means handed to that transport without an error. The Python wrapper builds the Bucker bytes (CPU only, no I/O) before the Sentry call so the Bucker copy does not carry the tag it then adds to Sentry's.

What Bucker records

The Bucker copy's envelope header carries a bucker_dual_send block: the shared event id, the Sentry event URL if you supplied one, and the SDK's own counters (sent to Sentry, sent to Bucker, failed on each side, dropped). Bucker treats it as a claim: it must name the same event id as the envelope, the URL must be https with no credentials, and the issue is found under the project of the DSN that sent it, never one named in the header. The link appears on the issue; an issue keeps the link of its newest dual-sent event.

The one-DSN switch

When you are satisfied, point the Sentry SDK's dsn at your Bucker DSN and remove the wrapper. Nothing else changes: Bucker accepts the Sentry SDK unmodified (see Sentry SDK compatibility), and the history in Sentry can be imported with the Sentry connector.

What it is not

It does not compare Sentry's grouping with Bucker's unless the Sentry connector holds your token; without it, grouping is not checked and Bucker says so rather than guessing. It does not copy Sentry's event content anywhere.