Cargo.toml

[package]
name = "jaeger-test"
version = "0.1.0"
edition = "2018"

# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html

[dependencies]
opentelemetry = { git = "https://github.com/open-telemetry/opentelemetry-rust.git", features = ["rt-tokio"] }#, rev = "414b3f459" }
opentelemetry-otlp = { git = "https://github.com/open-telemetry/opentelemetry-rust.git"} #, rev = "414b3f459" }
opentelemetry-jaeger = { git = "https://github.com/open-telemetry/opentelemetry-rust.git", features = ["rt-tokio"]} #, rev = "414b3f459" }
tokio = { version = "1.12.0", features = ["full"] }
tracing = "0.1.29"
tracing-opentelemetry = "0.15.0"
tracing-subscriber = "0.2.25"
tracing-futures = { version = "0.2.5", features = [ "tokio" ] }
futures = "0.3.17"

[patch.crates-io]
opentelemetry = { git = "https://github.com/open-telemetry/opentelemetry-rust.git" }#, rev = "414b3f459" }
opentelemetry-otlp = { git = "https://github.com/open-telemetry/opentelemetry-rust.git"} #, rev = "414b3f459" }
opentelemetry-jaeger = { git = "https://github.com/open-telemetry/opentelemetry-rust.git"} #, rev = "414b3f459" }

[profile.release]
debug = true

flamegraph.svg

main.rs

use futures::stream::{self, StreamExt};
use opentelemetry::global;
use opentelemetry::trace::Tracer;
use tracing::{error, event, instrument::WithSubscriber, span, Instrument, Level};
use tracing_subscriber::layer::SubscriberExt;
use tracing_subscriber::Registry;

const delay: u64 = 10;
const query: &'static str = "query ExampleQuery($topProductsFirst: Int) {
  me {
      id
    }

      topProducts(first: $topProductsFirst) {
          name
              price
                  inStock
                    }

          topProducts(first: $topProductsFirst) {
      name
              price
                      inStock

                }
    }
                                                ";

#[tokio::main]
async fn main() -> Result<(), opentelemetry::trace::TraceError> {
    let subscriber = tracing_subscriber::fmt::fmt().finish();

    let tracer = opentelemetry_jaeger::new_pipeline()
        .with_service_name("jaeger-perf-test")
        .install_batch(opentelemetry::runtime::Tokio)?;

    let telemetry = tracing_opentelemetry::layer().with_tracer(tracer);
    let subscriber = subscriber.with(telemetry);

    run().with_subscriber(subscriber).await;

    global::shutdown_tracer_provider(); // export remaining spans

    Ok(())
}

async fn run() {
    let mut s = stream::repeat(()).enumerate();

    while let Some((i, _)) = s.next().instrument(tracing::info_span!("stream")).await {
        event!(Level::INFO, count = i);
        a(i).instrument(tracing::info_span!("a", query))
            .instrument(tracing::info_span!("aa"))
            .await;
    }
}

async fn a(i: usize) {
    let f1 = format!("1: got {}", i);
    let f2 = format!("2: got {}", i);
    let f3 = format!("3: got {}", i);
    let f4 = format!("4: got {}", i);
    let f5 = format!("5: got {}", i);

    let v = vec![
        b(f1.as_str(), 2)
            .instrument(tracing::info_span!("b", factor = 0.5))
            .instrument(tracing::info_span!("bb")),
        b(f2.as_str(), 3)
            .instrument(tracing::info_span!("b", factor = 0.3))
            .instrument(tracing::info_span!("bb")),
        b(f3.as_str(), 4)
            .instrument(tracing::info_span!("b", factor = 0.25))
            .instrument(tracing::info_span!("bb")),
        b(f4.as_str(), 1)
            .instrument(tracing::info_span!("b", factor = 1))
            .instrument(tracing::info_span!("bb")),
        b(f5.as_str(), 1)
            .instrument(tracing::info_span!("b", factor = 1))
            .instrument(tracing::info_span!("bb")),
    ];

    futures::future::join_all(v).await;
}

async fn b(s: &str, div: u64) {
    tokio::time::sleep(std::time::Duration::from_millis(delay / div))
        .instrument(tracing::info_span!("wait", query))
        .await;

    c(s).instrument(tracing::info_span!("c", query)).await;
}

async fn c(s: &str) {
    let t = std::time::SystemTime::now()
        .duration_since(std::time::SystemTime::UNIX_EPOCH)
        .unwrap()
        .as_secs();
    println!("{}: {}", t, s);
}