Docs Set up your stack
Set up Relia in Go, Rust, Java, .NET and other languages
Connect an app in any language to Relia through OpenTelemetry, the open standard, with seven settings and your language's official OpenTelemetry setup.
Node.js, Python and PHP have Relia's one-command setup. Every other language connects through OpenTelemetry, the open standard most languages and monitoring tools support. Your app uses the official OpenTelemetry libraries, so nothing in your code is tied to Relia. Incidents, the APIs page, database queries and fix plans work the same.
Before you start
- A Relia account (Create your account).
- Access to where your app is started: your host's settings, a Dockerfile or docker-compose file, a systemd unit, or a start script.
Steps
Open the settings card. In Relia, open your project and click Setup Guide & SDK. Under Or set it up yourself, pick the tile Go, Rust, Java…. The card's settings are already filled in with your project's values.
Copy the seven settings. They look like this:
OTEL_EXPORTER_OTLP_ENDPOINT=https://devotel.tryrelia.com OTEL_EXPORTER_OTLP_PROTOCOL=http/protobuf OTEL_EXPORTER_OTLP_HEADERS=x-relia-key=<your project key> OTEL_RESOURCE_ATTRIBUTES=relia.project_id=<your project id>,deployment.environment.name=production OTEL_SERVICE_NAME=api OTEL_METRICS_EXPORTER=none OTEL_LOGS_EXPORTER=noneThe first line says where your data goes. The headers line holds your project key, and the next line your project id.
Paste them where your app starts, as environment variables. Go, Rust, Java and .NET don't read a
.envfile by themselves.On your laptop, change
productiontodevelopmentso test traffic stays apart from production.Add your language's OpenTelemetry setup (below). Already using OpenTelemetry, for example with Datadog, Honeycomb or Grafana? Skip this step: the settings are all you change.
Tip: your AI assistant knows these steps for Go, Rust, Java and others. Watch Set up production monitoring with one sentence to your AI assistant (2 min).
Restart your app and use it once: open a page or call an endpoint. Data arrives within a minute.
Go
Tested with net/http. Install:
go get go.opentelemetry.io/otel go.opentelemetry.io/otel/sdk go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp github.com/XSAM/otelsql
Pick Go on the card and add the file relia.go it shows as it is, then run go mod tidy. In main:
- call
setupReliafirst, and wrap your server withotelhttp.NewHandler(mux, "server"); - register routes with the card's
handlehelper, so each request carries its route template (/orders/{id}) and Relia shows one row per route, not one per order. With Gin, Echo or Chi, use their OpenTelemetry middleware (otelgin,otelecho,otelchi) instead; - open databases with
otelsql.Openplusotelsql.WithAttributes(attribute.String("db.system", "postgresql"))(ormysql,sqlite) so they show on the Database page; - stop the server cleanly on a signal so the last requests are sent.
log.Fatalskips that.
Rust
Tested with axum. Install:
cargo add opentelemetry@0.33 opentelemetry_sdk@0.33 opentelemetry-http@0.33 tracing-opentelemetry@0.34 tracing tracing-subscriber
cargo add opentelemetry-otlp@0.33 --no-default-features --features http-proto,reqwest-blocking-client,trace
The versions are pinned on purpose: the Rust OpenTelemetry libraries change between minor versions. Pick Rust on the card, add the src/relia.rs it shows as it is, and add mod relia; to main.rs. Call relia::init() first, add .layer(axum::middleware::from_fn(relia::trace_requests)) after your routes, serve with .with_graceful_shutdown(relia::shutdown_signal()), then call provider.shutdown() so the last requests are sent.
Java and Kotlin
Spring Boot, Quarkus, Micronaut or plain Java, with no code change. Download the official agent and start your app with it:
curl -L -O https://github.com/open-telemetry/opentelemetry-java-instrumentation/releases/download/v2.33.1/opentelemetry-javaagent.jar
java -javaagent:opentelemetry-javaagent.jar -jar your-app.jar
Requests, database calls, outgoing calls and exceptions are recorded. Don't commit the jar (it's over 20 MB): download it in your Dockerfile or start script.
.NET, Ruby and others
Use your language's official OpenTelemetry setup with the OTLP exporter over HTTP, and the same settings:
- .NET: the OpenTelemetry .NET automatic instrumentation.
- Ruby:
opentelemetry-sdk,opentelemetry-exporter-otlpandopentelemetry-instrumentation-all.
Good to know
- One name per app: give each app its own
OTEL_SERVICE_NAME. Two apps under one name are mixed together. - Route templates matter: a request should carry
http.route(like/orders/{id}). - Who made a request: set the span attributes
relia.user_idandrelia.user_plan(never an e-mail). See Identify your users. - Database values: Relia's own SDKs remove values from queries. With OpenTelemetry that depends on your library; placeholders (
$1,?) keep values out.
Check it worked
Open your project in Relia and go to the Setup tab. Requests from your server changes from Not yet to Arriving. Your requests and errors appear under APIs.
If something's wrong
- Nothing arrives: the variables must be set in the environment of the running process, not in a
.envfile the app never reads. - The last requests before a stop are missing: shut the tracer down when the app stops.
- One row per id instead of per route: the request spans don't carry
http.route. In Go, use thehandlehelper. - Still "Not yet": see Relia shows no data.
Next
- Set up Relia with your AI assistant, which knows these steps too
- Identify your users
- Monitor API requests and errors
Last checked against the product: 1 Nov 2026