qrt_log_utils/

lib.rs

use opentelemetry::{global, KeyValue};
use opentelemetry_appender_tracing::layer::OpenTelemetryTracingBridge;
use opentelemetry_otlp::{LogExporter, MetricExporter, SpanExporter, WithExportConfig};
use opentelemetry_sdk::logs::SdkLoggerProvider;
use opentelemetry_sdk::metrics::{PeriodicReader, SdkMeterProvider};
use opentelemetry_sdk::trace::SdkTracerProvider;
use opentelemetry_sdk::Resource;
use std::sync::OnceLock;
use std::time::Duration;
use tracing_subscriber::prelude::*;
use tracing_subscriber::EnvFilter;

// pub use for client
pub use opentelemetry;
use opentelemetry::trace::TracerProvider;
pub use tracing;

const DEFAULT_ENDPOINT: &'static str = "http://localhost:4317";

pub struct LoggerContext {
    pub logger_provider: SdkLoggerProvider,
    pub tracer_provider: SdkTracerProvider,
    pub meter_provider: SdkMeterProvider,
}

impl LoggerContext {
    pub fn shudown(self) {
        let _ = self.meter_provider.shutdown();
        let _ = self.tracer_provider.shutdown();
        let _ = self.logger_provider.shutdown();
    }
}

fn get_resource(service_name: &'static str) -> Resource {
    static RESOURCE: OnceLock<Resource> = OnceLock::new();
    RESOURCE
        .get_or_init(|| {
            let mut builder = Resource::builder().with_service_name(service_name);

            #[cfg(feature = "detect-host")]
            {
                builder =
                    builder.with_attribute(gen_host_info().expect("failed to build host info"));
            }

            builder.build()
        })
        .clone()
}
fn init_traces(endpoint: &str, service_name: &'static str) -> SdkTracerProvider {
    let exporter = SpanExporter::builder()
        .with_tonic()
        .with_endpoint(endpoint)
        .build()
        .expect("Failed to create span exporter");
    SdkTracerProvider::builder()
        .with_resource(get_resource(service_name))
        .with_batch_exporter(exporter)
        .build()
}

fn init_metrics(endpoint: &str, service_name: &'static str) -> SdkMeterProvider {
    let exporter = MetricExporter::builder()
        .with_tonic()
        .with_endpoint(endpoint)
        .build()
        .expect("Failed to create metric exporter");

    let reader = PeriodicReader::builder(exporter)
        .with_interval(Duration::from_secs(1))
        .build();
    SdkMeterProvider::builder()
        .with_reader(reader)
        .with_resource(get_resource(service_name))
        .build()
}

fn init_logs(endpoint: &str, service_name: &'static str) -> SdkLoggerProvider {
    let exporter = LogExporter::builder()
        .with_tonic()
        .with_endpoint(endpoint)
        .build()
        .expect("Failed to create log exporter");

    SdkLoggerProvider::builder()
        .with_resource(get_resource(service_name))
        .with_batch_exporter(exporter)
        .build()
}

fn init_tracer(
    application_name: &'static str,
    endpoint: &str,
    provider: SdkTracerProvider,
) -> SdkLoggerProvider {
    let logger_provider = init_logs(endpoint, application_name);

    // Create a new OpenTelemetryTracingBridge using the above LoggerProvider.
    let otel_layer = OpenTelemetryTracingBridge::new(&logger_provider);

    // For the OpenTelemetry layer, add a tracing filter to filter events from
    // OpenTelemetry and its dependent crates (opentelemetry-otlp uses crates
    // like reqwest/tonic etc.) from being sent back to OTel itself, thus
    // preventing infinite telemetry generation. The filter levels are set as
    // follows:
    // - Allow `info` level and above by default.
    // - Restrict `opentelemetry`, `hyper`, `tonic`, and `reqwest` completely.
    // Note: This will also drop events from crates like `tonic` etc. even when
    // they are used outside the OTLP Exporter. For more details, see:
    // https://github.com/open-telemetry/opentelemetry-rust/issues/761
    let filter_otel = EnvFilter::new("info")
        .add_directive("hyper=off".parse().unwrap())
        .add_directive("opentelemetry=off".parse().unwrap())
        .add_directive("tonic=off".parse().unwrap())
        .add_directive("h2=off".parse().unwrap());
    let otel_layer = otel_layer.with_filter(filter_otel);

    // Create a new tracing::Fmt layer to print the logs to stdout. It has a
    // default filter of `info` level and above, and `debug` and above for logs
    // from OpenTelemetry crates. The filter levels can be customized as needed.
    let filter = EnvFilter::from_default_env()
        .add_directive(format!("{}=info", &application_name).parse().unwrap());
    println!("filter={}", &filter);
    let tracer = provider.tracer("trace_demo");
    let telemetry = tracing_opentelemetry::layer().with_tracer(tracer);
    let fmt_layer = tracing_subscriber::fmt::layer()
        .with_thread_names(true)
        .with_filter(filter);

    // Initialize the tracing subscriber with the OpenTelemetry layer and the
    // Fmt layer.
    tracing_subscriber::registry()
        .with(otel_layer)
        .with(telemetry)
        .with(fmt_layer)
        .init();
    logger_provider
}

#[derive(Debug, Default)]
pub struct LoggerConfig {
    pub endpoint: Option<String>,
}

pub fn init_logger(service_name: &'static str, log_config: LoggerConfig) -> LoggerContext {
    let endpoint = log_config
        .endpoint
        .as_ref()
        .map(|v| v.as_str())
        .unwrap_or(DEFAULT_ENDPOINT);
    // default to allow log from current application
    let tracer_provider = init_traces(endpoint, service_name);
    let logger_provider = init_tracer(service_name, endpoint, tracer_provider.clone());
    global::set_tracer_provider(tracer_provider.clone());
    let meter_provider = init_metrics(endpoint, service_name);
    global::set_meter_provider(meter_provider.clone());
    LoggerContext {
        logger_provider,
        tracer_provider,
        meter_provider,
    }
}

#[cfg(feature = "detect-host")]
fn gen_host_info() -> Result<KeyValue, std::io::Error> {
    hostname::get().map(|val| {
        KeyValue::new(
            "host.name".to_string(),
            val.into_string().unwrap_or_else(|_| "unknown".into()),
        )
    })
}

#[cfg(test)]
mod test {
    use std::time::Duration;

    use opentelemetry::{global, KeyValue};
    use tracing::info;
    use tracing::instrument;

    use crate::{init_logger, LoggerConfig};

    #[instrument]
    fn foo() {
        // let trace = register_dist_tracing_root(TraceId::default(), None);
        // println!("trace value: {:?}", trace);
        info!("test");
        bar();
    }

    #[instrument]
    fn bar() {
        // let trace = register_dist_tracing_root(TraceId::default(), None);
        // println!("trace value: {:?}", trace);
        info!("test2");
    }

    #[tokio::test]
    async fn test_logger() {
        init_logger("test_logger", LoggerConfig::default());
        for _ in 0..100 {
            // let span = span!(Level::Info, "my_span");
            // let _guard = span.enter();
            foo();
        }
        tokio::time::sleep(Duration::from_secs(4)).await;
    }

    #[instrument]
    fn add_counter() {
        let counter = global::meter("aaa").f64_counter("testCounterF64").build();
        counter.add(10f64, &[KeyValue::new("rate", "standard")]);
    }
}