Platforms

Every platform the dashboard's setup picker offers, with the same four steps it shows — here with the placeholder DSN, there with your project's own. Each says how much of it ships today: Ships means install it now; Hand-wired means it ships but the snippet wires by hand what the SDK does not wire for you; Compatible, not certified means that language's own Sentry SDK speaks the envelope format Bucker accepts, but no pinned release of it runs in the conformance suite, so nothing here vouches for a version; Planned means the SDK work does not exist yet, and the snippet is the closest honest path meanwhile.

Two entries need nothing of ours at all. Sentry SDK (any language) keeps the SDK you already run and changes only its DSN; OpenTelemetry points any OTel SDK or collector at Bucker with three environment variables. Between them, almost every language reports on day one.

Browser JavaScript

Ships.

Packages: @bucker/browser (npm).

Install

One dependency, tree-shakeable.

npm install @bucker/browser

Configure

Run this once, as early as possible on every page.

import { init } from '@bucker/browser'

init({
  dsn: 'https://<publicKey>@us.ingest.bucker.io/<projectId>',
  environment: 'production',
  release: 'web@1.0.0',
})

Verify

Paste it in the browser console of a page that loaded the SDK.

import { captureException } from '@bucker/browser'

captureException(new Error('Bucker verify: deliberate browser error'))

Next

Upload source maps with @bucker/bundler-plugin so stack traces point at your source.

Node.js

Ships.

Packages: @bucker/node (npm).

Install

One dependency; it has none of its own.

npm install @bucker/node

Configure

Import this module first thing at startup, so the crash handlers are in place before anything else runs.

import { init } from '@bucker/node'

export const bucker = init({
  dsn: 'https://<publicKey>@us.ingest.bucker.io/<projectId>',
  environment: process.env.NODE_ENV,
  release: process.env.APP_VERSION,
})

Verify

Run it once; the issue appears within seconds.

import { captureException, flush } from '@bucker/node'

captureException(new Error('Bucker verify: deliberate server error'))
await flush()

Next

Set release so regressions and crash-free rates line up with deploys.

Next.js

Hand-wired. There is no Next.js SDK: create-bucker writes instrumentation.ts (server, @bucker/node) and instrumentation-client.ts (browser, @bucker/browser) for you.

Packages: @bucker/node (npm), @bucker/browser (npm).

Install

create-bucker installs both packages for you.

Configure

It writes instrumentation.ts and instrumentation-client.ts and touches no config file.

npx create-bucker --dsn "https://<publicKey>@us.ingest.bucker.io/<projectId>" --framework nextjs

Verify

Open the /bucker-verify route it adds; it throws on purpose.

Next

Set release so regressions and crash-free rates line up with deploys.

Flutter

Ships. Dart-layer errors only: native crashes (Swift, Kotlin, NDK) and ANRs are not captured yet, which is most real-world mobile crash volume.

Packages: bucker_flutter (pub).

Install

Dart-layer capture; native crashes are not captured yet.

flutter pub add bucker_flutter

Configure

init installs FlutterError.onError and the platform dispatcher handler before runApp.

import 'package:bucker_flutter/bucker_flutter.dart';

Future<void> main() async {
  await Bucker.init(
    dsn: 'https://<publicKey>@us.ingest.bucker.io/<projectId>',
    environment: 'production',
    release: 'com.acme.app@1.0.0+1',
  );
  runApp(const MyApp());
}

Verify

Call it from a debug button once.

Bucker.captureException(StateError('Bucker verify: deliberate error'));

Next

Set release so regressions and crash-free rates line up with deploys.

Python

Ships.

Packages: bucker-sdk (pypi).

Install

Pure Python, no compiled dependencies.

pip install bucker-sdk

Configure

Call it once, at process start.

import bucker_sdk

bucker_sdk.init(
    dsn="https://<publicKey>@us.ingest.bucker.io/<projectId>",
    environment="production",
)

Verify

Run it once from the same environment.

import bucker_sdk

bucker_sdk.capture_exception(RuntimeError("Bucker verify: deliberate error"))

Next

Set release so regressions and crash-free rates line up with deploys.

Something else

Hand-wired. No Bucker SDK targets it, so use the Sentry SDK for your language or an OpenTelemetry exporter — both report to Bucker unchanged.

Install

No Bucker SDK targets this platform.

Configure

Either path reports to Bucker unchanged.

# The Sentry SDK for your language, with this DSN:
https://<publicKey>@us.ingest.bucker.io/<projectId>

# …or any OpenTelemetry exporter:
OTEL_EXPORTER_OTLP_ENDPOINT=https://us.ingest.bucker.io
OTEL_EXPORTER_OTLP_HEADERS="Authorization=DSN https://<publicKey>@us.ingest.bucker.io/<projectId>"
OTEL_EXPORTER_OTLP_PROTOCOL=http/protobuf

Verify

Trigger one error through whichever path you chose.

Next

The ingest protocol page documents the envelope format for a client of your own.

Sentry SDK (any language)

Ships. Keep the Sentry SDK you have and change only its DSN. Errors carry over today; transactions, spans and replays are accepted and not yet shown as issues.

Install

Nothing to install: keep the Sentry SDK you already run, in any language.

Configure

Swap the DSN and nothing else. Every Sentry SDK takes it the same way (sentry_sdk.init(dsn=…), sentry.Init(sentry.ClientOptions{Dsn: …}), Sentry.init { dsn = … }).

Sentry.init({
  dsn: 'https://<publicKey>@us.ingest.bucker.io/<projectId>',
})

Verify

Trigger any error your app already reports to Sentry.

Next

Errors carry over today; transactions, spans and replays are accepted and not yet shown as issues. See "Evaluate without migrating" to keep both running.

OpenTelemetry

Ships. Traces, logs and metrics over OTLP/HTTP from any OTel SDK or collector, with three environment variables.

Install

Nothing of ours to install: any OpenTelemetry SDK or collector.

Configure

An unmodified exporter appends /v1/traces, /v1/logs and /v1/metrics itself.

OTEL_EXPORTER_OTLP_ENDPOINT=https://us.ingest.bucker.io
OTEL_EXPORTER_OTLP_HEADERS="Authorization=DSN https://<publicKey>@us.ingest.bucker.io/<projectId>"
OTEL_EXPORTER_OTLP_PROTOCOL=http/protobuf

Verify

Send one request through an instrumented service, then open Explore.

Next

Traces, logs and metrics are all accepted over OTLP; Explore reads each.

Express

Ships.

Packages: @bucker/node (npm).

Install

One dependency; it has none of its own.

npm install @bucker/node

Configure

requestHandler scopes each request; errorHandler reports what your routes throw.

import { errorHandler, init, requestHandler } from '@bucker/node'

export const bucker = init({
  dsn: 'https://<publicKey>@us.ingest.bucker.io/<projectId>',
  environment: process.env.NODE_ENV,
  release: process.env.APP_VERSION,
})

// after `const app = express()`, before your routes:
app.use(requestHandler(bucker))
// …and after them:
app.use(errorHandler(bucker))

Verify

Run it once; the issue appears within seconds.

import { captureException, flush } from '@bucker/node'

captureException(new Error('Bucker verify: deliberate server error'))
await flush()

Next

Set release so regressions and crash-free rates line up with deploys.

Fastify

Ships.

Packages: @bucker/node (npm).

Install

One dependency; it has none of its own.

npm install @bucker/node

Configure

Two hooks: one scopes each request, the other reports what a handler throws.

import { fastifyHooks, init } from '@bucker/node'

export const bucker = init({
  dsn: 'https://<publicKey>@us.ingest.bucker.io/<projectId>',
  environment: process.env.NODE_ENV,
  release: process.env.APP_VERSION,
})

const hooks = fastifyHooks(bucker)
app.addHook('onRequest', hooks.onRequest)
app.addHook('onError', hooks.onError)

Verify

Run it once; the issue appears within seconds.

import { captureException, flush } from '@bucker/node'

captureException(new Error('Bucker verify: deliberate server error'))
await flush()

Next

Set release so regressions and crash-free rates line up with deploys.

React

Ships.

Packages: @bucker/browser (npm).

Install

One dependency, tree-shakeable.

npm install @bucker/browser

Configure

Run init before createRoot and wrap the app in the ErrorBoundary: React catches component errors itself, so a window handler never sees them. captureRouteError covers a React Router or Remix route ErrorBoundary.

import { init } from '@bucker/browser'
import { ErrorBoundary } from '@bucker/browser/react'

init({
  dsn: 'https://<publicKey>@us.ingest.bucker.io/<projectId>',
  environment: 'production',
  release: 'web@1.0.0',
})

createRoot(document.getElementById('root')!).render(
  <ErrorBoundary fallback={<p>Something broke.</p>}>
    <App />
  </ErrorBoundary>,
)

Verify

Paste it in the browser console of a page that loaded the SDK.

import { captureException } from '@bucker/browser'

captureException(new Error('Bucker verify: deliberate browser error'))

Next

Upload source maps with @bucker/bundler-plugin so stack traces point at your source.

Vue

Ships.

Packages: @bucker/browser (npm).

Install

One dependency, tree-shakeable.

npm install @bucker/browser

Configure

Run init before createApp, then install the plugin: it sets app.config.errorHandler and chains yours.

import { init } from '@bucker/browser'
import { buckerVue } from '@bucker/browser/vue'

init({
  dsn: 'https://<publicKey>@us.ingest.bucker.io/<projectId>',
  environment: 'production',
  release: 'web@1.0.0',
})

const app = createApp(App)
app.use(buckerVue)
app.mount('#app')

Verify

Paste it in the browser console of a page that loaded the SDK.

import { captureException } from '@bucker/browser'

captureException(new Error('Bucker verify: deliberate browser error'))

Next

Upload source maps with @bucker/bundler-plugin so stack traces point at your source.

Angular

Hand-wired. Angular catches its own errors, so provide the ErrorHandler @bucker/browser/angular builds in app.config.ts — it replaces the default one, and logs as it did.

Packages: @bucker/browser (npm).

Install

One dependency, tree-shakeable.

npm install @bucker/browser

Configure

Run init in main.ts and provide the ErrorHandler in app.config.ts: Angular catches its own errors, so a window handler never sees them. The two pieces are shown together here.

import { init } from '@bucker/browser'
import { ErrorHandler, type ApplicationConfig } from '@angular/core'
import { createErrorHandler } from '@bucker/browser/angular'

init({
  dsn: 'https://<publicKey>@us.ingest.bucker.io/<projectId>',
  environment: 'production',
  release: 'web@1.0.0',
})

// app.config.ts
export const appConfig: ApplicationConfig = {
  providers: [{ provide: ErrorHandler, useValue: createErrorHandler() }],
}

Verify

Paste it in the browser console of a page that loaded the SDK.

import { captureException } from '@bucker/browser'

captureException(new Error('Bucker verify: deliberate browser error'))

Next

Upload source maps with @bucker/bundler-plugin so stack traces point at your source.

Svelte

Ships.

Packages: @bucker/browser (npm).

Install

One dependency, tree-shakeable.

npm install @bucker/browser

Configure

Run this in your entry module, before the app mounts.

import { init } from '@bucker/browser'

init({
  dsn: 'https://<publicKey>@us.ingest.bucker.io/<projectId>',
  environment: 'production',
  release: 'web@1.0.0',
})

Verify

Paste it in the browser console of a page that loaded the SDK.

import { captureException } from '@bucker/browser'

captureException(new Error('Bucker verify: deliberate browser error'))

Next

Upload source maps with @bucker/bundler-plugin so stack traces point at your source.

SvelteKit

Hand-wired. Two hooks files, one line each: @bucker/node/sveltekit in hooks.server.ts, @bucker/browser/svelte in hooks.client.ts.

Packages: @bucker/node (npm), @bucker/browser (npm).

Install

Two packages: one for each half of the app.

npm install @bucker/node @bucker/browser

Configure

Server half: sveltekitHandle scopes each request and sveltekitHandleError reports what a load or action throws (a 4xx is not reported). Browser half: buckerHandleError in hooks.client.ts.

// src/hooks.server.ts
import { sequence } from '@sveltejs/kit/hooks'
import { init } from '@bucker/node'
import { sveltekitHandle, sveltekitHandleError } from '@bucker/node/sveltekit'

const bucker = init({ dsn: 'https://<publicKey>@us.ingest.bucker.io/<projectId>', environment: process.env.NODE_ENV })

export const handle = sequence(sveltekitHandle(bucker) /*, yourHandle */)
export const handleError = sveltekitHandleError(bucker)

// src/hooks.client.ts
import { init } from '@bucker/browser'
import { buckerHandleError } from '@bucker/browser/svelte'

init({ dsn: 'https://<publicKey>@us.ingest.bucker.io/<projectId>', environment: 'production' })

export const handleError = buckerHandleError()

Verify

Throw once from a server route to see the server half arrive.

import { captureException, flush } from '@bucker/node'

captureException(new Error('Bucker verify: deliberate server error'))
await flush()

Next

Set release so regressions and crash-free rates line up with deploys.

Nuxt

Hand-wired. Two plugins, one line each: @bucker/node/nuxt in a Nitro plugin, @bucker/browser/nuxt in a client-only Nuxt plugin.

Packages: @bucker/node (npm), @bucker/browser (npm).

Install

Two packages: one for each half of the app.

npm install @bucker/node @bucker/browser

Configure

Server half: a Nitro plugin puts nitroErrorHook on the 'error' hook. Browser half: a client-only Nuxt plugin calls installNuxt, which listens for vue:error and app:error.

// server/plugins/bucker.ts
import { init } from '@bucker/node'
import { nitroErrorHook } from '@bucker/node/nuxt'

const bucker = init({ dsn: 'https://<publicKey>@us.ingest.bucker.io/<projectId>', environment: process.env.NODE_ENV })

export default defineNitroPlugin((nitroApp) => {
  nitroApp.hooks.hook('error', nitroErrorHook(bucker))
})

// plugins/bucker.client.ts
import { init } from '@bucker/browser'
import { installNuxt } from '@bucker/browser/nuxt'

export default defineNuxtPlugin((nuxtApp) => {
  init({ dsn: 'https://<publicKey>@us.ingest.bucker.io/<projectId>', environment: 'production' })
  installNuxt(nuxtApp)
})

Verify

Throw once from a server route to see the server half arrive.

import { captureException, flush } from '@bucker/node'

captureException(new Error('Bucker verify: deliberate server error'))
await flush()

Next

Set release so regressions and crash-free rates line up with deploys.

Remix

Hand-wired. Two entry files: @bucker/node/remix in entry.server handleError, @bucker/browser/react in the route ErrorBoundary.

Packages: @bucker/node (npm), @bucker/browser (npm).

Install

Two packages: one for each half of the app.

npm install @bucker/node @bucker/browser

Configure

Server half: export handleError from entry.server (a request the client aborted is skipped). Browser half: captureRouteError in the route ErrorBoundary, which React Router renders instead of throwing to the window.

// app/entry.server.tsx
import { init } from '@bucker/node'
import { remixHandleError } from '@bucker/node/remix'

const bucker = init({ dsn: 'https://<publicKey>@us.ingest.bucker.io/<projectId>', environment: process.env.NODE_ENV })

export const handleError = remixHandleError(bucker)

// app/root.tsx
import { init } from '@bucker/browser'
import { captureRouteError } from '@bucker/browser/react'
import { useRouteError } from 'react-router'

init({ dsn: 'https://<publicKey>@us.ingest.bucker.io/<projectId>', environment: 'production' })

export function ErrorBoundary() {
  captureRouteError(useRouteError())
  return <p>Something broke.</p>
}

Verify

Throw once from a server route to see the server half arrive.

import { captureException, flush } from '@bucker/node'

captureException(new Error('Bucker verify: deliberate server error'))
await flush()

Next

Set release so regressions and crash-free rates line up with deploys.

Django

Hand-wired. Wrap the WSGI application in BuckerWsgiMiddleware; there is no Django integration that does it for you.

Packages: bucker-sdk (pypi).

Install

Pure Python, no compiled dependencies.

pip install bucker-sdk

Configure

init in settings.py, the middleware in wsgi.py.

import bucker_sdk

bucker_sdk.init(
    dsn="https://<publicKey>@us.ingest.bucker.io/<projectId>",
    environment="production",
)

# wsgi.py
from bucker_sdk.wsgi import BuckerWsgiMiddleware
application = BuckerWsgiMiddleware(application)

Verify

Run it once from the same environment.

import bucker_sdk

bucker_sdk.capture_exception(RuntimeError("Bucker verify: deliberate error"))

Next

Set release so regressions and crash-free rates line up with deploys.

Flask

Hand-wired. Wrap app.wsgi_app in BuckerWsgiMiddleware; there is no Flask extension.

Packages: bucker-sdk (pypi).

Install

Pure Python, no compiled dependencies.

pip install bucker-sdk

Configure

Wrap the WSGI app after creating it.

import bucker_sdk

bucker_sdk.init(
    dsn="https://<publicKey>@us.ingest.bucker.io/<projectId>",
    environment="production",
)

from bucker_sdk.wsgi import BuckerWsgiMiddleware
app.wsgi_app = BuckerWsgiMiddleware(app.wsgi_app)

Verify

Run it once from the same environment.

import bucker_sdk

bucker_sdk.capture_exception(RuntimeError("Bucker verify: deliberate error"))

Next

Set release so regressions and crash-free rates line up with deploys.

FastAPI

Hand-wired. Add BuckerAsgiMiddleware to the app; it serves any ASGI framework the same way.

Packages: bucker-sdk (pypi).

Install

Pure Python, no compiled dependencies.

pip install bucker-sdk

Configure

Any ASGI framework takes the same middleware.

import bucker_sdk

bucker_sdk.init(
    dsn="https://<publicKey>@us.ingest.bucker.io/<projectId>",
    environment="production",
)

from bucker_sdk.asgi import BuckerAsgiMiddleware
app.add_middleware(BuckerAsgiMiddleware)

Verify

Run it once from the same environment.

import bucker_sdk

bucker_sdk.capture_exception(RuntimeError("Bucker verify: deliberate error"))

Next

Set release so regressions and crash-free rates line up with deploys.

Astro

Planned. No Astro integration yet. Use Browser JavaScript for the client islands meanwhile.

Install

One dependency, tree-shakeable.

npm install @bucker/browser

Configure

This platform has no Bucker SDK yet; the snippet is the closest honest path today.

import { init } from '@bucker/browser'

init({
  dsn: 'https://<publicKey>@us.ingest.bucker.io/<projectId>',
  environment: 'production',
  release: 'web@1.0.0',
})

Verify

Paste it in the browser console of a page that loaded the SDK.

import { captureException } from '@bucker/browser'

captureException(new Error('Bucker verify: deliberate browser error'))

Next

Upload source maps with @bucker/bundler-plugin so stack traces point at your source.

NestJS

Ships.

Packages: @bucker/node (npm).

Install

One dependency; it has none of its own.

npm install @bucker/node

Configure

A global filter reports what a handler throws and answers the request; an HttpException (a 4xx) is not reported.

import { BuckerExceptionFilter } from '@bucker/node/nestjs'
import { init } from '@bucker/node'

export const bucker = init({
  dsn: 'https://<publicKey>@us.ingest.bucker.io/<projectId>',
  environment: process.env.NODE_ENV,
  release: process.env.APP_VERSION,
})

// main.ts, after NestFactory.create(AppModule):
app.useGlobalFilters(new BuckerExceptionFilter({ client: bucker }))

Verify

Run it once; the issue appears within seconds.

import { captureException, flush } from '@bucker/node'

captureException(new Error('Bucker verify: deliberate server error'))
await flush()

Next

Set release so regressions and crash-free rates line up with deploys.

AWS Lambda

Ships.

Packages: @bucker/node (npm).

Install

One dependency; it has none of its own.

npm install @bucker/node

Configure

The wrapper flushes before the handler returns, bounded by the time Lambda says is left, so a frozen runtime never strands an event. init is given signalHandlers: false: there is no process left to crash.

import { wrapHandler } from '@bucker/node/lambda'
import { init } from '@bucker/node'

export const bucker = init({
  dsn: 'https://<publicKey>@us.ingest.bucker.io/<projectId>',
  environment: process.env.NODE_ENV,
  release: process.env.APP_VERSION,
  signalHandlers: false,
})

export const handler = wrapHandler(async (event, context) => {
  // your handler
})

Verify

Run it once; the issue appears within seconds.

import { captureException, flush } from '@bucker/node'

captureException(new Error('Bucker verify: deliberate server error'))
await flush()

Next

Set release so regressions and crash-free rates line up with deploys.

Celery

Planned. No Celery signal handlers yet. bucker_sdk.capture_exception in a task failure handler works meanwhile.

Install

Pure Python, no compiled dependencies.

pip install bucker-sdk

Configure

This platform has no Bucker SDK yet; the snippet is the closest honest path today. Call capture_exception from a task_failure signal handler.

import bucker_sdk

bucker_sdk.init(
    dsn="https://<publicKey>@us.ingest.bucker.io/<projectId>",
    environment="production",
)

Verify

Run it once from the same environment.

import bucker_sdk

bucker_sdk.capture_exception(RuntimeError("Bucker verify: deliberate error"))

Next

Set release so regressions and crash-free rates line up with deploys.

Hono

Ships.

Packages: @bucker/node (npm).

Install

One dependency; it has none of its own.

npm install @bucker/node

Configure

One middleware, registered first: it scopes each request and reports the error Hono leaves on c.error.

import { honoMiddleware } from '@bucker/node/hono'
import { init } from '@bucker/node'

export const bucker = init({
  dsn: 'https://<publicKey>@us.ingest.bucker.io/<projectId>',
  environment: process.env.NODE_ENV,
  release: process.env.APP_VERSION,
})

app.use('*', honoMiddleware(bucker))

Verify

Run it once; the issue appears within seconds.

import { captureException, flush } from '@bucker/node'

captureException(new Error('Bucker verify: deliberate server error'))
await flush()

Next

Set release so regressions and crash-free rates line up with deploys.

Koa

Ships.

Packages: @bucker/node (npm).

Install

One dependency; it has none of its own.

npm install @bucker/node

Configure

The middleware goes first so it sees every throw; the error listener catches what a custom error middleware swallowed.

import { koaErrorHandler, koaMiddleware } from '@bucker/node/koa'
import { init } from '@bucker/node'

export const bucker = init({
  dsn: 'https://<publicKey>@us.ingest.bucker.io/<projectId>',
  environment: process.env.NODE_ENV,
  release: process.env.APP_VERSION,
})

app.use(koaMiddleware(bucker)) // first, before every other middleware
app.on('error', koaErrorHandler(bucker))

Verify

Run it once; the issue appears within seconds.

import { captureException, flush } from '@bucker/node'

captureException(new Error('Bucker verify: deliberate server error'))
await flush()

Next

Set release so regressions and crash-free rates line up with deploys.

Edge runtimes

Hand-wired. A fetch-only entry with a waitUntil-aware flush, verified against fakes rather than workerd, Deno or Bun: smoke-test the runtime you deploy to.

Packages: @bucker/sdk-core (npm).

Install

The fetch-only entry: no Node built-ins, so it bundles for Workers, Vercel Edge, Deno and Bun.

npm install @bucker/sdk-core

Configure

With a platform context the flush is handed to waitUntil, so the response is not delayed and the isolate stays alive until the event is sent.

import { wrapFetch } from '@bucker/sdk-core/edge'

export default {
  fetch: wrapFetch((request, env, ctx) => app.fetch(request, env, ctx), () => ({
    dsn: 'https://<publicKey>@us.ingest.bucker.io/<projectId>',
  })),
}

Verify

Throw once from a request handler of the deployed app; a local dev server is not the runtime this entry is for.

Next

On Hono, call captureEdgeError from app.onError: Hono turns a throw into a response before wrapFetch sees it.

Go

Compatible, not certified. Grammar-compatible, not certified: sentry-go sends the envelope format Bucker accepts, but no pinned release of it runs in the conformance suite yet, so check the drops panel after the first deploy. Traces, logs and metrics can go over OpenTelemetry instead.

Install

The Sentry SDK for this language, unmodified. Bucker's own SDKs are JavaScript and Python.

go get github.com/getsentry/sentry-go

Configure

The Bucker DSN in place of a Sentry one is the whole change.

err := sentry.Init(sentry.ClientOptions{
	Dsn:         "https://<publicKey>@us.ingest.bucker.io/<projectId>",
	Environment: "production",
	Release:     "my-service@1.0.0",
})
if err != nil {
	log.Fatalf("sentry.Init: %s", err)
}
defer sentry.Flush(2 * time.Second)

Verify

Run it once; if no issue appears within a minute, the project's drops panel says why.

sentry.CaptureException(errors.New("Bucker verify: deliberate error"))
sentry.Flush(2 * time.Second)

Next

Not certified: no pinned release of this SDK runs in the conformance suite yet. For traces, logs and metrics, point an OpenTelemetry exporter at Bucker as well (the OpenTelemetry entry).

Ruby

Compatible, not certified. Grammar-compatible, not certified: sentry-ruby sends the envelope format Bucker accepts, but no pinned release of it runs in the conformance suite yet, so check the drops panel after the first deploy. Traces, logs and metrics can go over OpenTelemetry instead.

Install

The Sentry SDK for this language, unmodified. Bucker's own SDKs are JavaScript and Python.

bundle add sentry-ruby

Configure

The Bucker DSN in place of a Sentry one is the whole change.

Sentry.init do |config|
  config.dsn = 'https://<publicKey>@us.ingest.bucker.io/<projectId>'
  config.environment = 'production'
end

Verify

Run it once; if no issue appears within a minute, the project's drops panel says why.

Sentry.capture_exception(RuntimeError.new('Bucker verify: deliberate error'))

Next

Not certified: no pinned release of this SDK runs in the conformance suite yet. For traces, logs and metrics, point an OpenTelemetry exporter at Bucker as well (the OpenTelemetry entry).

PHP

Compatible, not certified. Grammar-compatible, not certified: sentry-php sends the envelope format Bucker accepts, but no pinned release of it runs in the conformance suite yet, so check the drops panel after the first deploy. Traces, logs and metrics can go over OpenTelemetry instead.

Install

The Sentry SDK for this language, unmodified. Bucker's own SDKs are JavaScript and Python.

composer require sentry/sentry

Configure

The Bucker DSN in place of a Sentry one is the whole change.

\Sentry\init([
    'dsn' => 'https://<publicKey>@us.ingest.bucker.io/<projectId>',
    'environment' => 'production',
]);

Verify

Run it once; if no issue appears within a minute, the project's drops panel says why.

\Sentry\captureException(new \RuntimeException('Bucker verify: deliberate error'));

Next

Not certified: no pinned release of this SDK runs in the conformance suite yet. For traces, logs and metrics, point an OpenTelemetry exporter at Bucker as well (the OpenTelemetry entry).

Java and Kotlin

Compatible, not certified. Grammar-compatible, not certified: sentry-java sends the envelope format Bucker accepts, but no pinned release of it runs in the conformance suite yet, so check the drops panel after the first deploy. Traces, logs and metrics can go over OpenTelemetry instead.

Install

The Sentry SDK for this language, unmodified. Bucker's own SDKs are JavaScript and Python.

# Gradle: implementation("io.sentry:sentry:8.+")  ·  Maven: io.sentry:sentry

Configure

The Bucker DSN in place of a Sentry one is the whole change.

Sentry.init(options -> {
    options.setDsn("https://<publicKey>@us.ingest.bucker.io/<projectId>");
    options.setEnvironment("production");
});

Verify

Run it once; if no issue appears within a minute, the project's drops panel says why.

Sentry.captureException(new RuntimeException("Bucker verify: deliberate error"));

Next

Not certified: no pinned release of this SDK runs in the conformance suite yet. For traces, logs and metrics, point an OpenTelemetry exporter at Bucker as well (the OpenTelemetry entry).

.NET

Compatible, not certified. Grammar-compatible, not certified: sentry-dotnet sends the envelope format Bucker accepts, but no pinned release of it runs in the conformance suite yet, so check the drops panel after the first deploy. Traces, logs and metrics can go over OpenTelemetry instead.

Install

The Sentry SDK for this language, unmodified. Bucker's own SDKs are JavaScript and Python.

dotnet add package Sentry

Configure

The Bucker DSN in place of a Sentry one is the whole change.

using var sentry = SentrySdk.Init(options =>
{
    options.Dsn = "https://<publicKey>@us.ingest.bucker.io/<projectId>";
    options.Environment = "production";
});

Verify

Run it once; if no issue appears within a minute, the project's drops panel says why.

SentrySdk.CaptureException(new Exception("Bucker verify: deliberate error"));

Next

Not certified: no pinned release of this SDK runs in the conformance suite yet. For traces, logs and metrics, point an OpenTelemetry exporter at Bucker as well (the OpenTelemetry entry).