Add ability to customize span names for TraceLayer

[horseinthesky]

• [ x] I have looked for existing issues (including closed) about this

Feature Request

At the moment addition of TraceLayer provides you no ability to name your span

let app = Router::new()
    .route("/api/devices", get(devices))
    .layer(
        TraceLayer::new_for_http()
            .make_span_with(DefaultMakeSpan::new().include_headers(true)),
    )
    .route(
        "/metrics",
        get(|| async { "metrics" }),
    );

As the result all spans are named request.

Motivation

It would be nice see method+endpoint uri instead. Something like GET /api/devices.
This would simplify working with spans on a collector side.

Proposal

I'm very new to Rust. If I'm not mistaken this is the place where request name code from
https://github.com/tower-rs/tower-http/blob/main/tower-http/src/trace/make_span.rs#L84-L101

Not sure how to achieve this.

[jplatte]

This is already possible, using make_span_with. See for example the following snippet in the docs: https://docs.rs/tower-http/latest/tower_http/trace/index.html#recording-fields-on-the-span

[horseinthesky]

This is already possible, using make_span_with. See for example the following snippet in the docs: docs.rs/tower-http/latest/tower_http/trace/index.html#recording-fields-on-the-span

Thanks a lot.

Every other attribute works great but struggling setting up the name

[horseinthesky]

Here is an example:

use axum::{routing::get, Json, Router};
use opentelemetry::KeyValue;
use axum_tracing_opentelemetry::middleware::OtelAxumLayer;
use opentelemetry_otlp::WithExportConfig;
use opentelemetry_sdk::Resource;
use opentelemetry_semantic_conventions as semconv;
use serde::Serialize;
use tracing::{debug, info, info_span, warn};
use tracing_subscriber::prelude::*;

mod devices;
use devices::{get_devices, Device};

#[derive(Serialize)]
struct Response<'a> {
    status: &'a str,
    message: &'a str,
}

fn init_otlp() {
    // Create OTLP gRPC exporter
    let exporter = opentelemetry_otlp::new_exporter()
        .grpcio()
        .with_endpoint("localhost:4317");

    // Create a resource
    let resource = Resource::new([KeyValue::new(
        semconv::resource::SERVICE_NAME,
        "rust-app",
    )]);

    // Create tracer
    let tracer = opentelemetry_otlp::new_pipeline()
        .tracing()
        .with_exporter(exporter)
        .with_trace_config(
            opentelemetry_sdk::trace::config().with_resource(resource),
        )
        .install_batch(opentelemetry_sdk::runtime::Tokio)
        .expect("should create a tracer");

    // Create an opentelemetry layer
    let otlp_layer = tracing_opentelemetry::layer().with_tracer(tracer);

    // Create a subscriber
    let subscriber = tracing_subscriber::Registry::default().with(otlp_layer);

    // Set the global subscriber for the app
    tracing::subscriber::set_global_default(subscriber).unwrap();
}

#[tokio::main]
async fn main() -> Result<(), axum::BoxError> {
    init_otlp();

    let app = Router::new()
        .route("/api/devices", get(devices))
        .layer(OtelAxumLayer::default())
        .route("/health", get(health));

    let listener = tokio::net::TcpListener::bind("127.0.0.1:8000")
        .await
        .unwrap();

    axum::serve(listener, app)
        .await?;

    Ok(())
}

async fn health() -> Json<Response<'static>> {
    Json(Response {
        status: "ok",
        message: "up",
    })
}

#[tracing::instrument]
async fn devices() -> Json<Vec<Device<'static>>> {
    info_span!("internal").in_scope(|| {
        warn!("do stuff inside internal");
    });

    Json(get_devices())
}

get_devices() just returns some static content. Doens't really matter.

Here is how traces look like in Tempo

Here is full trace info

So as I've said it's able to put HTTP method and URL to the trace name whatever they are i.e. dynamycally.

[jplatte]

Sure, there is a name field there that has a dynamic value. I don't think it's the same as the tracing span name though.

[horseinthesky]

What do you mean by saying "isn't the same"?

If I replace

.layer(OtelInResponseLayer::default())

with

.layer(
    TraceLayer::new_for_http()
        .make_span_with(DefaultMakeSpan::new().include_headers(true)),
)

there is no more method/url info in traces names.

detail

[jplatte]

I mean that the GET /api/devices string from your previous screenshot is not the tracing span's .metadata()?.name(). And indeed I think I found how it works: If there is a field named otel.name on the span, that's used in the Name column. Try writing something like this for make_span_with:

let name = format!("{whatever} {you} {want}");
info_span!(
    "request",
    otel.name = name,
    extra_field = value,
)

[horseinthesky]

Awesome! =)

Solution

.layer(
    TraceLayer::new_for_http().make_span_with(
        |request: &Request<_>| {
            let name =
                format!("{} {}", request.method(), request.uri());

            tracing::debug_span!(
                "request",
                otel.name = name,
                method = %request.method(),
                uri = %request.uri(),
                headers = ?request.headers(),
                version = ?request.version(),
            )
        },
    ),
)

Traces

Details

Thank you