Stack integrations

For existing Sentry, PostHog, Grafana/Loki, Datadog or webhook logs, use external log sources. Provider connections require no application SDK or Runtime ingest key. The application instrumentation path below uses Runtime credentials and OTLP/browser endpoints.

Credential	Where it lives	Can
Server key `autter_rt_…`	backend env vars only	send OTLP traces/metrics/logs + relay browser events
Client key `autter_rtc_…`	frontend bundles (publishable)	send browser events only, origin-restricted

Endpoint	Format
`POST /v1/traces`, `POST /v1/metrics`	OTLP/HTTP — protobuf or JSON, gzip ok
`POST /v1/logs`	OTLP/HTTP logs — protobuf or JSON; requires a compatible ingester deployment
`POST /v1/browser`	compact JSON (`@autter/runtime-browser` payload v1)

Any language with an OpenTelemetry SDK can send server telemetry — point its OTLP/HTTP exporter at the ingester and add the key as a header. Structured logs require a logs exporter and logger bridge in addition to tracing. Node/Next.js operation APIs require a release containing them; check installed and deployed support. Ordinary logs remain diagnostics; exception and failed-outcome traces produce issues. Keep your existing logging and provider ownership.

React / SPA / static sites

npm install @autter/runtime-browser

With a backend (recommended — relay, no key in the bundle):

initAutterBrowser({ endpoint: "/api/autter-runtime", service: "web-app" });

Static / serverless: same-origin relay (no backend needed)

Direct browser ingest (https://otlp.autter.dev/v1/browser with autter_rtc_…) is cross-origin and ad-blockers silently drop it. You avoid that loss on static sites by deploying the same-origin relay and keeping the tracker on /api/autter-runtime.

Cloudflare: deploy examples/runtime-relay (wrangler deploy), then route /api/autter-runtime* to it.
Vercel: copy examples/runtime-relay/vercel-edge-route.ts to app/api/autter-runtime/route.ts.
Init (all relay modes):

initAutterBrowser({ endpoint: "/api/autter-runtime", service: "web-app" });

Relay contract: POST-only, 64KB cap, Origin forwarded, Cookie stripped, 202 on accept. Set the AUTTER_RUNTIME_KEY secret to forward with your server key. Without a relay (lossy fallback for pure-static only, publishable client key, origin-restricted):

initAutterBrowser({
  endpoint: "https://otlp.autter.dev/v1/browser",
  clientKey: "autter_rtc_xxxxxxxx",
  service: "marketing-site",
});

Direct ingest is cross-origin. Ad-blockers silently drop these requests, so expect partial data. Use the same-origin relay above whenever you can deploy a Worker or edge route.

React render errors: wrap with <AutterErrorBoundary> (from @autter/runtime-next/client, works in any React app). Vue/Svelte/Angular: call captureException(err) from the framework’s error hook (app.config.errorHandler, handleError, ErrorHandler).

Node.js (Express, Fastify, Koa, NestJS)

npm install @autter/runtime-node

// instrument.cjs — load first: node --require ./instrument.cjs server.js
const { initAutterServer } = require("@autter/runtime-node");
initAutterServer({
  apiKey: process.env.AUTTER_RUNTIME_KEY,
  service: "payments-api",
  release: process.env.GIT_SHA,
});

Request ids and error hooks:

// Express: request ids first, the error hook after your routes
app.use(autterRequests());
app.use(autterErrorHandler());
// Fastify
app.register(autterFastifyErrors);
// Koa: first
app.use(autterKoa());

Each hook records a thrown error, with its stack, on the request span and leaves the response to the framework. Without one, a thrown error reaches Autter only as the 500 it caused (GET /route returned 500, no stack). Express is the exception from @autter/runtime-node 1.10.0: the SDK records the error behind every 5xx itself, in every router, including routers with their own error handler. autterErrorHandler() then only adds coded errors that end in a 4xx, and an error is never reported twice. Set captureExpressErrors: false in initAutterServer to turn the automatic capture off. Relay for your frontend:

app.post("/api/autter-runtime", createBrowserRelayHandler({ apiKey }));

ESM-only apps need OpenTelemetry’s loader hook — see the package README. For customer checkout/jobs, follow Operation logging: reuse initialization, add logging options after capability checks, and use withRuntimeOperation for steps and explicit business outcomes. Await flushing before short-lived work ends, and inspect stored logs plus linked issue evidence.

Next.js

npm install @autter/runtime-next

Three files — instrumentation.ts, a relay route, and a client init + boundary. See the package README. Server initialization, relay and operation logging use @autter/runtime-next/server; browser components use @autter/runtime-next/client. Logging operations require Node, not edge. See the Next.js logging example.

OTLP logs in other backends

Python, Go, Rust, Java, .NET and other backends can use their installed OTel logs SDK or a Collector logs pipeline with /v1/logs. Endpoint variables alone do not install a logger bridge. Include service/environment/release, active trace/span IDs and scrubbed context, and configure exporter buffering and lifecycle flushing. Node’s limits and helper APIs do not apply to these stacks. See OTLP logger setup and the operation attribute contract.

Go

import (
    "go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp"
)

exp, _ := otlptracehttp.New(ctx,
    otlptracehttp.WithEndpointURL("https://otlp.autter.dev/v1/traces"),
    otlptracehttp.WithHeaders(map[string]string{
        "authorization": "Bearer " + os.Getenv("AUTTER_RUNTIME_KEY"),
    }),
)
// resource: service.name, service.version (release), deployment.environment
// errors: span.RecordError(err); span.SetStatus(codes.Error, err.Error())

Rust

// opentelemetry-otlp with the "http-proto" (default) or "http-json" feature
let exporter = opentelemetry_otlp::SpanExporter::builder()
    .with_http()
    .with_endpoint("https://otlp.autter.dev/v1/traces")
    .with_headers(HashMap::from([(
        "authorization".into(),
        format!("Bearer {}", std::env::var("AUTTER_RUNTIME_KEY")?),
    )]))
    .build()?;

Python, Java, .NET, or anything else

Standard OpenTelemetry environment variables work with every SDK:

OTEL_EXPORTER_OTLP_ENDPOINT=https://otlp.autter.dev
OTEL_EXPORTER_OTLP_HEADERS="authorization=Bearer ${AUTTER_RUNTIME_KEY}"
OTEL_EXPORTER_OTLP_PROTOCOL=http/protobuf
OTEL_SERVICE_NAME=payments-api
OTEL_RESOURCE_ATTRIBUTES=service.version=${GIT_SHA},deployment.environment=production
OTEL_TRACES_SAMPLER=parentbased_traceidratio
OTEL_TRACES_SAMPLER_ARG=0.01

Errors surface as issues when spans carry exception events (every SDK’s record_exception / RecordError does this) or ERROR status. The ingester parses each language’s native stack format (Go, Rust, Java, .NET, Python, JavaScript), so errors group by function and file, not by message alone — the same defect stays one issue and unrelated errors that share a message stay apart. Warnings (any language): add an autter.severity attribute to the exception event — "fatal" | "error" | "warning" | "info" (default error; the Node SDK’s crash marker autter.unhandled: true implies fatal). Warnings share the errors table with a severity column, so they group and aggregate identically:

span.record_exception(err)  # or add_event("exception", {...})
span.set_attribute("autter.severity", "warning")

Sampling guidance (all stacks)

Errors are always worth sending; keep successful-trace sampling at ~1% (OTEL_TRACES_SAMPLER_ARG=0.01). Request/usage metrics are derived server-side from spans and the http.server.duration histogram — no extra setup.

No @autter/* package for your language?

Send telemetry with just an OpenTelemetry SDK, a Collector, or a hand-rolled HTTP request.

Get started

Guides

Reference

Stack integrations

React / SPA / static sites

Static / serverless: same-origin relay (no backend needed)

Node.js (Express, Fastify, Koa, NestJS)

Next.js

OTLP logs in other backends

Go

Rust

Python, Java, .NET, or anything else

Sampling guidance (all stacks)

No @autter/* package for your language?