Två vägar in, och båda är standard
JavaScript och TypeScript har vår egen klient. Alla andra språk går in via OpenTelemetry, alltså med standardens egna bibliotek och inte med något vi har skrivit. Det betyder att instrumenteringen ni gör i dag fungerar mot vilken mottagare som helst, också mot någon annans.
OTLP in, utan egen agent
Skickar era tjänster redan OTLP är hela arbetet två miljövariabler. Ingen agent installeras på maskinen, ingen sidovagn körs bredvid tjänsten, och ingen kod byts ut.
- Samma inmatning tar emot spår, loggar och mätvärden. En adress, inte tre.
- Protokollet är http/protobuf. Biblioteket lägger på sökvägen per signal, alltså v1/traces, v1/logs eller v1/metrics.
- Nyckeln går i huvudet x-gaddr-key. Den är publik och skriver bara.
- Kör ni redan en OpenTelemetry Collector pekar ni om dess exportör och rör inte tjänsterna alls.
OpenTelemetry in, utan egen agent, står i planen Fri i packages/pricing/src/index.ts. Adressen och nyckeln står i projektets inställningar.
OTEL_EXPORTER_OTLP_ENDPOINT="https://log.gaddr.com/api/otlp"
OTEL_EXPORTER_OTLP_PROTOCOL="http/protobuf"
OTEL_EXPORTER_OTLP_HEADERS="x-gaddr-key=gdr_pk_din_nyckel"
OTEL_SERVICE_NAME="kassa-api"
OTEL_RESOURCE_ATTRIBUTES="deployment.environment=production,service.version=2026.8.15"
service.version fyller samma roll som release i vår egen klient. Sätt den till samma sträng som bygget bär, så kopplas felet till commiten som byggde det.
En adress tar emot spår, loggar och mätvärden. 
Ingen agent på maskinen och ingen sidovagn bredvid tjänsten.
JavaScript och TypeScript
Det enda språket med vår egen klient. Paketet väger lite, kastar aldrig vidare in i er kod, och bär taket och maskningen inbyggda. install kopplar in fönstrets felhanterare och avvisade löften, och returnerar en funktion som kopplar loss dem igen.
- Samma paket i webbläsaren och på servern.
- Nyckeln är publik och får ligga i klientbygget.
- Kör ni redan OpenTelemetry i Node behöver ni inte paketet alls.
1import { initTelemetry } from "@gaddr/telemetry";
2
3const log = initTelemetry({
4 ingestKey: "gdr_pk_din_nyckel",
5 environment: "production",
6 release: "web@2026.8.15",
7});
8
9log.install();
Tre rader. install kopplar in error, unhandledrejection och en tömning när fliken göms. Hela vägen står i kom igång.
Python
Den automatiska instrumenteringen känner igen ramverket och webbserverns anrop utan att ni skriver någon kod. Kör tjänsten med opentelemetry-instrument, sätt två miljövariabler, och spåren landar i samma vy som fel och loggar.
- opentelemetry-bootstrap installerar instrumenteringen för de paket ni redan har.
- Django, FastAPI och Flask känns igen utan konfiguration.
- Loggar och mätvärden går samma väg som spåren, med samma två variabler.
1pip install opentelemetry-distro opentelemetry-exporter-otlp
2opentelemetry-bootstrap --action=install
3
4export OTEL_EXPORTER_OTLP_ENDPOINT="https://log.gaddr.com/api/otlp"
5export OTEL_EXPORTER_OTLP_HEADERS="x-gaddr-key=gdr_pk_din_nyckel"
6export OTEL_SERVICE_NAME="kassa-api"
7
8opentelemetry-instrument python manage.py runserver
Adressen och nyckeln står i projektets inställningar. OTEL_SERVICE_NAME är det namn tjänsten får i vyn, så sätt det till något ni känner igen klockan tre på natten.
Go
Go instrumenteras i koden och inte med en agent. Exportören går över HTTP, leverantören sätts en gång i main, och otelhttp lägger sig runt er befintliga hanterare utan att ni skriver om den.
- otelhttp.NewHandler tar den hanterare ni redan har.
- slog kopplas till spåret, så att loggraden bär samma spår-id.
- Avstängningen töms i en defer, så att det sista som hände hinner ut.
1exp, err := otlptracehttp.New(ctx,
2 otlptracehttp.WithEndpointURL("https://log.gaddr.com/api/otlp/v1/traces"),
3 otlptracehttp.WithHeaders(map[string]string{"x-gaddr-key": nyckel}),
4)
5
6tp := trace.NewTracerProvider(trace.WithBatcher(exp))
7otel.SetTracerProvider(tp)
8defer tp.Shutdown(ctx)
9
10http.Handle("/", otelhttp.NewHandler(mux, "http"))
WithBatcher buntar spåren på samma sätt som vår egen klient buntar händelser. Ett anrop per bunt i stället för ett per span är skillnaden mellan en mätbar kostnad och en osynlig.
Rust
Rust går in genom tracing, som ni troligen redan använder. Lagret från tracing-opentelemetry skickar vidare det ni redan skriver, alltså behöver ni inte byta makro i koden för att få spår.
- tracing::info och tracing::error blir händelser utan att skrivas om.
- axum instrumenteras med ett lager, inte med en ändring per rutt.
- Exporten är buntad, och den töms vid avstängning.
1let exporter = opentelemetry_otlp::SpanExporter::builder()
2 .with_http()
3 .with_endpoint("https://log.gaddr.com/api/otlp/v1/traces")
4 .with_headers(HashMap::from([("x-gaddr-key".into(), nyckel)]))
5 .build()?;
6
7let provider = SdkTracerProvider::builder()
8 .with_batch_exporter(exporter)
9 .build();
10
11tracing_subscriber::registry()
12 .with(OpenTelemetryLayer::new(provider.tracer("api")))
13 .init();
Registret från tracing_subscriber är det enda stället som ändras. Resten av koden fortsätter använda tracing precis som förut.
PHP
PHP instrumenteras med en tillägsmodul och ett paket via Composer. Den automatiska instrumenteringen känner igen Laravel och Symfony, och anropen mot databasen och kön kommer med utan att ni rör en controller.
- Modulen laddas i php.ini, paketen installeras med Composer.
- Laravels köer och Symfonys meddelandebuss instrumenteras utan kod.
- Konfigurationen ligger i miljövariabler, alltså per miljö och inte i koden.
1pecl install opentelemetry
2composer require open-telemetry/sdk open-telemetry/exporter-otlp
3
4OTEL_PHP_AUTOLOAD_ENABLED="true"
5OTEL_TRACES_EXPORTER="otlp"
6OTEL_EXPORTER_OTLP_PROTOCOL="http/protobuf"
7OTEL_EXPORTER_OTLP_ENDPOINT="https://log.gaddr.com/api/otlp"
8OTEL_EXPORTER_OTLP_HEADERS="x-gaddr-key=gdr_pk_din_nyckel"
9OTEL_SERVICE_NAME="butik-web"
Raderna nedanför composer är miljövariabler och hör hemma i er miljöfil, inte i koden. Med autoload påslaget behöver ni inte anropa något själva för att få de vanliga ramverken instrumenterade.
Java
Java behöver inte en enda rad ny kod. Agenten hängs på vid start, känner igen Spring, Micronaut, JDBC, Kafka och de flesta klienter ni redan använder, och skickar vidare över OTLP.
- En jar-fil på kommandoraden, ingen ändring i bygget.
- Spring Boot och Micronaut känns igen utan konfiguration.
- Samma agent skickar spår, mätvärden och loggar.
1java -javaagent:opentelemetry-javaagent.jar \
2 -Dotel.service.name=order-service \
3 -Dotel.exporter.otlp.endpoint=https://log.gaddr.com/api/otlp \
4 -Dotel.exporter.otlp.headers=x-gaddr-key=gdr_pk_din_nyckel \
5 -Dotel.exporter.otlp.protocol=http/protobuf \
6 -jar order-service.jar
Agenten laddas före er kod och instrumenterar biblioteken när de laddas. Vill ni lägga till egna spann gör ni det med annoteringen WithSpan, men ni behöver inte göra det för att komma i gång.
iOS och Android
Mobilt går in med OpenTelemetrys egna bibliotek för Swift och för Android. Kraschen, nätverksanropen och skärmbytena blir händelser i samma vy som webben och api:t, och de knyts ihop av spår-id:t när det följer med anropet.
- Swift-paketet läggs till med Swift Package Manager.
- Android-paketet läggs till med Gradle och startas i Application.
- Ett anrop från appen till ert api hamnar i samma spår som serverns steg.
1let exporter = OtlpHttpTraceExporter(
2 endpoint: URL(string: "https://log.gaddr.com/api/otlp/v1/traces")!,
3 config: OtlpConfiguration(headers: [("x-gaddr-key", nyckel)])
4)
5
6OpenTelemetry.registerTracerProvider(
7 tracerProvider: TracerProviderBuilder()
8 .add(spanProcessor: BatchSpanProcessor(spanExporter: exporter))
9 .build()
10)
På Android är motsvarigheten OtlpHttpSpanExporter med samma adress och samma huvud, satt en gång i er Application-klass.
Samma tak gäller oavsett vilket bibliotek som skickade. 
Kvoten nollställs vid månadsskiftet utan att ni gör något.
Taket sitter i projektet, inte i biblioteket
Vår egen klient bär taket i koden som skickar. Skickar ni OTLP från ett annat språk sitter samma tak i projektet i stället, alltså på mottagningssidan.
- Volym över kvoten tas inte emot, och det som inte tas emot faktureras inte.
- Inmatningen svarar GDR-LOG-0500 när kvoten är förbrukad, oavsett vilket bibliotek som skickade.
- Höjningen är ett aktivt val ni gör i projektet, aldrig en automatisk uppgradering.
- Kvoten nollställs vid månadsskiftet utan att ni gör någonting.
Det ni undrar om vägen in
Vanliga frågor
Måste vi använda ert bibliotek?
Nej, utom i webbläsaren där vår klient är det enklaste. Allt annat går in via OpenTelemetry, och den instrumenteringen är inte vår. Den fungerar mot vilken mottagare som helst, alltså kan ni byta från oss utan att röra koden.
Behöver vi installera en agent på servern?
Nej. OTLP går direkt från tjänsten till oss. Kör ni redan en OpenTelemetry Collector fungerar den precis som förut, ni pekar bara om dess exportör.
Vilket protokoll ska vi välja?
http/protobuf. Det går genom brandväggar och lastbalanserare som vilken HTTPS-trafik som helst, och det är standardvärdet i de flesta bibliotek.
Kan ett anrop från appen hamna i samma spår som serverns steg?
Ja. Spår-id:t följer med anropet, och stegen på båda sidor hamnar i samma träd. Det är det som gör att en långsam skärm i appen går att spåra till en väntande databaspool.
Var får vi tag på adressen och nyckeln?
I projektets inställningar. Nyckeln börjar på gdr_pk_, är publik, och går att återkalla och byta ut när ni vill.
Vad kostar det att skicka från fler språk?
Ingenting extra. Ni betalar för volymen som kommer in, inte för antalet tjänster, antalet språk eller antalet personer som läser. Planen Fri kostar 0 kr, och prissidan har hela listan.
Skicka första händelsen i kväll
Kom igång tar er från installation till första felet i vyn, med maskningen redan på och taket redan satt.
