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_urltag (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.
transformForBuckerruns on Bucker's copy; returnnullto 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.