// pick your stack Copy a working snippet.
Each path below is a complete, copy-pasteable starting point. Drop it in, run, and your first span lands in Telemtra.
// python Python OpenTelemetry config
Auto-instrument a Flask, Django, or FastAPI app without touching source code. Install the OpenTelemetry distro, set two environment variables, and launch under opentelemetry-instrument — auto-instrumentation patches frameworks at import time.
python shell
pip install opentelemetry-distro opentelemetry-exporter-otlp-proto-http
opentelemetry-bootstrap --action=install
export OTEL_SERVICE_NAME=checkout-api
export OTEL_EXPORTER_OTLP_ENDPOINT=https://ingest.telemtra.io
export OTEL_EXPORTER_OTLP_HEADERS="x-api-key=${TELEMTRA_API_KEY}"
opentelemetry-instrument python app.py
Full OpenTelemetry Python guide →
// node.js Node.js OpenTelemetry config
Auto-instrument Express, Fastify, NestJS, Koa, and most popular Node.js libraries by registering auto-instrumentations-node at process start with --require. No code changes inside your app.
node.js shell
npm install @opentelemetry/api @opentelemetry/auto-instrumentations-node \
@opentelemetry/exporter-trace-otlp-http \
@opentelemetry/exporter-logs-otlp-http \
@opentelemetry/exporter-metrics-otlp-http
export OTEL_SERVICE_NAME=checkout-api
export OTEL_EXPORTER_OTLP_ENDPOINT=https://ingest.telemtra.io
export OTEL_EXPORTER_OTLP_HEADERS="x-api-key=${TELEMTRA_API_KEY}"
node --require @opentelemetry/auto-instrumentations-node/register app.js
Full OpenTelemetry Node.js guide →
// go Go OpenTelemetry config
Go has no auto-instrumentation; wire the SDK explicitly in main and add per-library instrumentations (otelhttp, otelgin, otelpgx) as needed. The block below is the minimum trace exporter setup that sends OTLP/HTTP to Telemtra.
go main.go
import (
"go.opentelemetry.io/otel"
"go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp"
sdktrace "go.opentelemetry.io/otel/sdk/trace"
)
exp, _ := otlptracehttp.New(ctx,
otlptracehttp.WithEndpointURL("https://ingest.telemtra.io"),
otlptracehttp.WithHeaders(map[string]string{
"x-api-key": os.Getenv("TELEMTRA_API_KEY"),
}),
)
tp := sdktrace.NewTracerProvider(sdktrace.WithBatcher(exp))
otel.SetTracerProvider(tp)
Full OpenTelemetry Go guide →
// java Java OpenTelemetry config
Attach the OpenTelemetry Java agent JAR at JVM startup — zero source code, build file, or dependency changes. The agent instruments Spring, JDBC, Kafka, gRPC, OkHttp, Jetty, and dozens more at class load.
java shell
curl -L -o opentelemetry-javaagent.jar \
https://github.com/open-telemetry/opentelemetry-java-instrumentation/releases/latest/download/opentelemetry-javaagent.jar
java \
-javaagent:opentelemetry-javaagent.jar \
-Dotel.service.name=checkout-api \
-Dotel.exporter.otlp.endpoint=https://ingest.telemtra.io \
-Dotel.exporter.otlp.protocol=http/protobuf \
-Dotel.exporter.otlp.headers=x-api-key=${TELEMTRA_API_KEY} \
-jar app.jar
Full OpenTelemetry Java guide →
// .net .NET OpenTelemetry config
Register OpenTelemetry in Program.cs with NuGet packages for ASP.NET Core, HttpClient, and Entity Framework Core. OTLP/HTTP export over https://ingest.telemtra.io; the hosted service flushes pending spans on graceful shutdown.
.net Program.cs
dotnet add package OpenTelemetry.Extensions.Hosting
dotnet add package OpenTelemetry.Exporter.OpenTelemetryProtocol
dotnet add package OpenTelemetry.Instrumentation.AspNetCore
// Program.cs
builder.Services.AddOpenTelemetry()
.ConfigureResource(r => r.AddService("checkout-api"))
.WithTracing(t => t
.AddAspNetCoreInstrumentation()
.AddOtlpExporter(o =>
{
o.Endpoint = new Uri("https://ingest.telemtra.io/v1/traces");
o.Protocol = OtlpExportProtocol.HttpProtobuf;
o.Headers = $"x-api-key={Environment.GetEnvironmentVariable("TELEMTRA_API_KEY")}";
}));
Full OpenTelemetry .NET guide →
// rust Rust OpenTelemetry config
Rust routes everything through the tracing crate: a single tracing-opentelemetry layer turns your existing tracing::info! and #[instrument] calls into OTLP spans. Add the crates with cargo add opentelemetry opentelemetry_sdk opentelemetry-otlp tracing tracing-opentelemetry tracing-subscriber, then wire the exporter once at startup.
rust main.rs
use opentelemetry::global;
use opentelemetry_otlp::WithExportConfig;
use tracing_subscriber::{layer::SubscriberExt, util::SubscriberInitExt};
let exporter = opentelemetry_otlp::new_exporter()
.http()
.with_endpoint("https://ingest.telemtra.io")
.with_headers(std::collections::HashMap::from([(
"x-api-key".to_string(),
std::env::var("TELEMTRA_API_KEY")?,
)]));
let tracer_provider = opentelemetry_otlp::new_pipeline()
.tracing()
.with_exporter(exporter)
.install_batch(opentelemetry_sdk::runtime::Tokio)?;
global::set_tracer_provider(tracer_provider.clone());
tracing_subscriber::registry()
.with(tracing_opentelemetry::layer().with_tracer(tracer_provider.tracer("checkout-api")))
.init();
Full OpenTelemetry Rust guide →
// docker Docker Compose OpenTelemetry config
Add three OTEL environment variables to any service in docker-compose.yml. Pair with any OpenTelemetry SDK above to ship traces, logs, and metrics from a containerised app to Telemtra.
docker docker-compose.yml
services:
app:
image: your-app:latest
environment:
OTEL_SERVICE_NAME: checkout-api
OTEL_EXPORTER_OTLP_ENDPOINT: https://ingest.telemtra.io
OTEL_EXPORTER_OTLP_HEADERS: "x-api-key=${TELEMTRA_API_KEY}"
Full OpenTelemetry Docker guide →
// kubernetes Kubernetes OpenTelemetry config
Store the API key in a Kubernetes Secret, load it into the pod as TELEMTRA_API_KEY, then build the full OTLP header from it with Kubernetes' $(VAR) substitution. OTel expects x-api-key=<key>, not the raw key, so the OTEL_EXPORTER_OTLP_HEADERS value is composed in a second env entry.
kubernetes deployment.yaml
apiVersion: v1
kind: Secret
metadata:
name: telemtra
stringData:
api-key: tk_live_xxxxxxxxxxxxxxxxxxxx
---
env:
- name: OTEL_SERVICE_NAME
value: checkout-api
- name: OTEL_EXPORTER_OTLP_ENDPOINT
value: https://ingest.telemtra.io
- name: TELEMTRA_API_KEY
valueFrom:
secretKeyRef:
name: telemtra
key: api-key
- name: OTEL_EXPORTER_OTLP_HEADERS
value: "x-api-key=$(TELEMTRA_API_KEY)"
Full OpenTelemetry Kubernetes guide →
// collector OpenTelemetry Collector config
If your apps already export OTLP to a Collector, add this exporter and pipeline reference — no SDK changes upstream. Run side-by-side with your current backend's exporter to evaluate Telemtra without committing to a cut-over.
collector otelcol-config.yaml
exporters:
otlp/telemtra:
endpoint: ingest.telemtra.io:443
headers:
x-api-key: ${env:TELEMTRA_API_KEY}
service:
pipelines:
traces: { exporters: [otlp/telemtra] }
logs: { exporters: [otlp/telemtra] }
metrics: { exporters: [otlp/telemtra] }
Full OpenTelemetry Collector guide →
