Rust logs installation

cargo add opentelemetry opentelemetry_sdk opentelemetry-appender-tracing tracing
cargo add tracing-subscriber --features env-filter
cargo add opentelemetry-otlp --features reqwest-rustls

use std::collections::HashMap;

use opentelemetry_appender_tracing::layer::OpenTelemetryTracingBridge;
use opentelemetry_otlp::{LogExporter, Protocol, WithExportConfig, WithHttpConfig};
use opentelemetry_sdk::{logs::SdkLoggerProvider, Resource};
use tracing_subscriber::{prelude::*, EnvFilter};

fn init_logs() -> SdkLoggerProvider {
    // use the blocking client even in an async app, the batch processor exports from
    // its own thread and the async reqwest-client feature panics there
    let exporter = LogExporter::builder()
        .with_http()
        .with_endpoint("https://us.i.posthog.com/i/v1/logs")
        .with_protocol(Protocol::HttpBinary)
        .with_headers(HashMap::from([(
            "Authorization".to_string(),
            "Bearer <ph_project_token>".to_string(),
        )]))
        .build()
        .expect("failed to build the OTLP log exporter");

    // you could also set the service name outside your application, with OTEL_SERVICE_NAME
    let provider = SdkLoggerProvider::builder()
        .with_resource(Resource::builder().with_service_name("my-service").build())
        .with_batch_exporter(exporter)
        .build();

    // the transport crates log through tracing too, so their output would loop back
    let export_filter = EnvFilter::new("info")
        .add_directive("opentelemetry=off".parse().unwrap())
        .add_directive("hyper=off".parse().unwrap())
        .add_directive("h2=off".parse().unwrap())
        .add_directive("reqwest=off".parse().unwrap());

    tracing_subscriber::registry()
        .with(OpenTelemetryTracingBridge::new(&provider).with_filter(export_filter))
        // export failures are only reported here, so keep this layer
        .with(
            tracing_subscriber::fmt::layer().with_filter(
                EnvFilter::new("info").add_directive("opentelemetry=debug".parse().unwrap()),
            ),
        )
        .init();

    provider
}

fn main() {
    // keep the provider alive for the lifetime of the process
    let provider = init_logs();

    tracing::info!("this is a log line");

    // flush on graceful exit, logs emitted after this are dropped. on tokio's
    // current-thread runtime call this from spawn_blocking, it can deadlock
    if let Err(err) = provider.shutdown() {
        eprintln!("failed to flush logs: {err}");
    }
}

.with_endpoint("https://us.i.posthog.com/i/v1/logs?token=<ph_project_token>")

// debug! and trace! are excluded by the info filter above
tracing::info!(user_id = "123", action = "login", "User action");
tracing::warn!(endpoint = "/old-api", "Deprecated API used");
tracing::error!(error = "Connection timeout", "Database connection failed");

// these keys are matched exactly, snake_case versions won't link
tracing::info!(posthogDistinctId = %user_id, sessionId = %session_id, "Checkout completed");