lxy 0.1.1

A convenient async http and RPC framework in Rust
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95

//! Builder for OpenTelemetry tracing integration.

use opentelemetry::trace::TracerProvider;
use opentelemetry_otlp::WithExportConfig;
use opentelemetry_sdk::trace::{
  BatchSpanProcessor, Sampler, SdkTracerProvider, SimpleSpanProcessor,
};

use super::config::{ExporterProtocol, OtelConfig, SpanProcessorType};

/// Initializes the OpenTelemetry tracer provider based on configuration.
pub fn init_tracer_provider(config: &OtelConfig) -> SdkTracerProvider {
  let exporter = create_exporter(config);

  match config.processor {
    SpanProcessorType::Simple => {
      let processor = SimpleSpanProcessor::new(exporter);
      SdkTracerProvider::builder()
        .with_sampler(Sampler::AlwaysOn)
        .with_span_processor(processor)
        .with_resource(
          opentelemetry_sdk::Resource::builder()
            .with_service_name(config.service_name.clone())
            .build(),
        )
        .build()
    }
    SpanProcessorType::Batch => {
      let processor = BatchSpanProcessor::builder(exporter).build();
      SdkTracerProvider::builder()
        .with_sampler(Sampler::AlwaysOn)
        .with_span_processor(processor)
        .with_resource(
          opentelemetry_sdk::Resource::builder()
            .with_service_name(config.service_name.clone())
            .build(),
        )
        .build()
    }
  }
}

/// Creates an OTLP exporter based on the protocol configuration.
fn create_exporter(config: &OtelConfig) -> opentelemetry_otlp::SpanExporter {
  match config.protocol {
    ExporterProtocol::Grpc => opentelemetry_otlp::SpanExporter::builder()
      .with_tonic()
      .with_endpoint(config.endpoint.clone())
      .build()
      .unwrap_or_else(|e| {
        panic!(
          "Failed to build OTLP gRPC exporter for endpoint '{}': {}",
          config.endpoint, e
        )
      }),
    ExporterProtocol::Http => opentelemetry_otlp::SpanExporter::builder()
      .with_http()
      .with_endpoint(config.endpoint.clone())
      .build()
      .unwrap_or_else(|e| {
        panic!(
          "Failed to build OTLP HTTP exporter for endpoint '{}': {}",
          config.endpoint, e
        )
      }),
  }
}

/// Creates an OpenTelemetry tracing layer for integration with `tracing-subscriber`.
///
/// This layer bridges the `tracing` ecosystem with OpenTelemetry, allowing spans
/// created via `tracing` macros to be exported to OpenTelemetry-compatible backends.
pub fn create_otel_layer<S>(
  provider: &SdkTracerProvider,
) -> tracing_opentelemetry::OpenTelemetryLayer<S, opentelemetry_sdk::trace::Tracer>
where
  S: tracing::Subscriber + for<'span> tracing_subscriber::registry::LookupSpan<'span>,
{
  let tracer = provider.tracer("lxy");
  tracing_opentelemetry::layer().with_tracer(tracer)
}

#[cfg(test)]
mod tests {
  use super::*;

  #[test]
  fn test_otel_config_defaults() {
    let config = OtelConfig::default();
    assert_eq!(config.service_name, "lxy-service");
    assert_eq!(config.endpoint, "http://localhost:4317");
    assert_eq!(config.protocol, ExporterProtocol::Http);
    assert_eq!(config.processor, SpanProcessorType::Simple);
  }
}