Rust - Rocketgraph

Rust has no runtime agent. In practice you keep the tracing crate you already have and bridge it to OpenTelemetry, so existing #[instrument] attributes start being exported without rewriting them.

Add the crates

cargo add opentelemetry opentelemetry_sdk
cargo add opentelemetry-otlp --features http-proto,reqwest-client
cargo add tracing tracing-subscriber tracing-opentelemetry

The http-proto feature matters. Without it the exporter is built for gRPC and will not talk to the HTTP ingress.

Initialise

use opentelemetry::{global, KeyValue};
use opentelemetry_otlp::{Protocol, WithExportConfig};
use opentelemetry_sdk::{trace::SdkTracerProvider, Resource};
use tracing_subscriber::{layer::SubscriberExt, util::SubscriberInitExt};

fn init_telemetry() -> SdkTracerProvider {
    let exporter = opentelemetry_otlp::SpanExporter::builder()
        .with_http()
        .with_protocol(Protocol::HttpBinary)
        .with_endpoint("https://ingress.rocketlog.io/v1/traces")
        .with_headers(std::collections::HashMap::from([(
            "Authorization".to_string(),
            "Bearer rg_live_xxxxxx".to_string(),
        )]))
        .build()
        .expect("build OTLP exporter");

    let provider = SdkTracerProvider::builder()
        .with_batch_exporter(exporter)
        .with_resource(
            Resource::builder()
                .with_attributes([KeyValue::new("service.name", "my-rust-service")])
                .build(),
        )
        .build();

    global::set_tracer_provider(provider.clone());

    tracing_subscriber::registry()
        .with(tracing_subscriber::fmt::layer())
        .with(tracing_opentelemetry::layer().with_tracer(
            opentelemetry::trace::TracerProvider::tracer(&provider, "my-rust-service"),
        ))
        .init();

    provider
}

The Rust builder API has changed shape more than once across releases. If this does not compile, check the version Cargo resolved — the docs for that exact version are authoritative.

Use it, and shut it down

#[tokio::main]
async fn main() {
    let provider = init_telemetry();

    run_server().await;

    // Not optional: the batch exporter holds spans in memory and nothing
    // flushes them for you on exit.
    provider.shutdown().expect("flush telemetry");
}

#[tracing::instrument(fields(transfer.id = %transfer_id))]
async fn settle_transfer(transfer_id: &str) -> Result<(), Error> {
    Ok(())
}