Tracing + Opentelemetry_OTLP

main.rs

mod telemetry;
use tracing::{ info, instrument, Level };
use telemetry::initialize;
// use tracing_subscriber::prelude::*;

#[instrument]
fn one() {
    println!("one")
}
#[tokio::main]
async fn main() {
    initialize();
    // let fmt_layer = tracing_subscriber::fmt::layer();
    // tracing_subscriber::registry().with(fmt_layer).init();
    // match initialize() {
    //     Ok(_) => {}
    //     Err(e) => {
    //         println!("Failed to initialize telemetry: {}", e);
    //     }
    // };
    info!("Hello, world!");
}

tracing.rs

use tracing_subscriber::{fmt, Registry};
use tracing_subscriber::prelude::*;
use tracing_subscriber::filter::EnvFilter;

use opentelemetry_otlp::WithExportConfig;

type TelError = Box<dyn std::error::Error + Send + Sync + 'static>;

fn create_otlp_tracer() -> Option<opentelemetry_sdk::trace::Tracer> {
    if !std::env::vars().any(|(name, _)| name.starts_with("OTEL_")) {
        return None;
    }

    let mut exporter = opentelemetry_otlp::new_exporter()
        .tonic()
        .with_endpoint("http://localhost:4317/v1/traces");

    let mut tracer = opentelemetry_otlp::new_pipeline()
        .tracing()
        .with_exporter(exporter);

    Some(tracer.install_batch(opentelemetry_sdk::runtime::Tokio).unwrap())
}


fn stdout_w_tele() -> Result<(), TelError> {
    let service_name = env!("CARGO_BIN_NAME");
    let tracer = create_otlp_tracer();

    let filter = EnvFilter::try_from_default_env()
        .or_else(|_| EnvFilter::try_new("debug")).expect("Failed to create filter");

    let std_out = fmt::layer()
        .pretty()
        // .with_thread_ids(true)
        // .with_thread_names(true)
        .with_file(true)
        .with_line_number(true)
        // .with_timer(timer::ChronoLocal::rfc3339())
        // .with_span_events(FmtSpan::EXIT)
        .with_filter(filter);
    
    let otel_layer = tracing_opentelemetry::layer().with_tracer(tracer);

    Registry::default()
        .with(std_out)
        .with(otel_layer)
        .init();
    
    // -- vvv -- This works
    // Registry::default()
    //     .with(std_out)
    //     .with(tracing_subscriber::EnvFilter::from_default_env())
    //     .init();

    Ok(())
}

pub fn initialize() -> Result<(), TelError> {
    stdout_w_tele()?;
    Ok(())
}