feat: configure endpoint

Author: ymgyt

crates/synd_o11y/src/opentelemetry/resource.rs

@@ -10,12 +10,7 @@ pub fn resource(
     service_name: impl Into<Cow<'static, str>>,
     service_version: impl Into<Cow<'static, str>>,
 ) -> Resource {
-    Resource::from_detectors(
-        Duration::from_millis(200),
-        // Detect "OTEL_RESOURCE_ATTRIBUTES" environment variables
-        vec![Box::new(EnvResourceDetector::new())],
-    )
-    .merge(&Resource::from_schema_url(
+    Resource::from_schema_url(
         [
             (SERVICE_NAME, service_name.into()),
             (SERVICE_VERSION, service_version.into()),
@@ -24,5 +19,10 @@ pub fn resource(
         .into_iter()
         .map(|(key, value)| KeyValue::new(key, value)),
         SCHEMA_URL,
+    )
+    .merge(&Resource::from_detectors(
+        Duration::from_millis(200),
+        // Detect "OTEL_RESOURCE_ATTRIBUTES" environment variables
+        vec![Box::new(EnvResourceDetector::new())],
     ))
 }

crates/synd_o11y/src/tracing_subscriber/otel_log/mod.rs

@@ -1,5 +1,5 @@
 use opentelemetry_appender_tracing::layer::OpenTelemetryTracingBridge;
-use opentelemetry_otlp::WithExportConfig;
+use opentelemetry_otlp::WithExportConfig as _;
 use opentelemetry_sdk::{runtime, Resource};
 use tracing::Subscriber;
 use tracing_subscriber::{registry::LookupSpan, Layer};

crates/synd_o11y/src/tracing_subscriber/otel_metrics/mod.rs

@@ -1,6 +1,17 @@
 use std::time::Duration;
 
-use opentelemetry_sdk::{metrics::MeterProvider, runtime, Resource};
+use opentelemetry::{
+    global,
+    metrics::{MeterProvider, Unit},
+};
+use opentelemetry_otlp::WithExportConfig as _;
+use opentelemetry_sdk::{
+    metrics::{
+        reader::{DefaultAggregationSelector, DefaultTemporalitySelector},
+        Instrument, MeterProvider as SdkMeterProvider, PeriodicReader, Stream, View,
+    },
+    runtime, Resource,
+};
 use tracing::{Metadata, Subscriber};
 use tracing_opentelemetry::MetricsLayer;
 use tracing_subscriber::{filter::filter_fn, layer::Filter, registry::LookupSpan, Layer};
@@ -13,23 +24,68 @@ pub fn metrics_event_filter<S: Subscriber>() -> impl Filter<S> {
     filter_fn(|metadata: &Metadata<'_>| metadata.target() != METRICS_EVENT_TARGET)
 }
 
-pub fn layer<S>(resource: Resource) -> impl Layer<S>
+pub fn layer<S>(endpoint: impl Into<String>, resource: Resource) -> impl Layer<S>
 where
     S: Subscriber + for<'span> LookupSpan<'span>,
 {
-    MetricsLayer::new(init_meter_provider(resource))
+    MetricsLayer::new(init_meter_provider(endpoint, resource))
 }
 
-fn init_meter_provider(resource: Resource) -> MeterProvider {
-    let provider = opentelemetry_otlp::new_pipeline()
-        .metrics(runtime::Tokio)
-        .with_resource(resource)
-        .with_exporter(opentelemetry_otlp::new_exporter().tonic())
-        .with_period(Duration::from_secs(60))
-        .build()
+fn init_meter_provider(endpoint: impl Into<String>, resource: Resource) -> impl MeterProvider {
+    // Currently OtelpMetricPipeline does not provide a way to set up views.
+    let exporter = opentelemetry_otlp::new_exporter()
+        .tonic()
+        .with_endpoint(endpoint)
+        .build_metrics_exporter(
+            Box::new(DefaultAggregationSelector::new()),
+            Box::new(DefaultTemporalitySelector::new()),
+        )
         .unwrap();
 
-    opentelemetry::global::set_meter_provider(provider.clone());
+    let reader = PeriodicReader::builder(exporter, runtime::Tokio)
+        .with_interval(Duration::from_secs(60))
+        .build();
+
+    let view = view();
+
+    let meter_provider = SdkMeterProvider::builder()
+        .with_resource(resource)
+        .with_reader(reader)
+        .with_view(view)
+        .build();
+
+    global::set_meter_provider(meter_provider.clone());
+
+    meter_provider
+}
+
+fn view() -> impl View {
+    |instrument: &Instrument| -> Option<Stream> {
+        tracing::debug!("{instrument:?}");
 
-    provider
+        match instrument.name.as_ref() {
+            "graphql.duration" => Some(
+                Stream::new()
+                    .name(instrument.name.clone())
+                    .description("graphql response duration")
+                    // Currently we could not ingest metrics with Arregation::Base2ExponentialHistogram in grafanacloud
+                    .aggregation(
+                        opentelemetry_sdk::metrics::Aggregation::ExplicitBucketHistogram {
+                            // https://opentelemetry.io/docs/specs/semconv/http/http-metrics/#http-server
+                            boundaries: vec![
+                                0.005, 0.01, 0.025, 0.05, 0.075, 0.1, 0.25, 0.5, 0.75, 1.0, 2.5,
+                                5.0, 7.5, 10.0,
+                            ],
+                            record_min_max: false,
+                        },
+                    )
+                    // https://opentelemetry.io/docs/specs/semconv/general/metrics/#instrument-units
+                    .unit(Unit::new("s")),
+            ),
+            name => {
+                tracing::info!(name, "There is no explicit view");
+                None
+            }
+        }
+    }
 }

crates/synd_o11y/src/tracing_subscriber/otel_trace/mod.rs

@@ -1,3 +1,4 @@
+use opentelemetry_otlp::WithExportConfig;
 use opentelemetry_sdk::{
     runtime,
     trace::{BatchConfig, Sampler, Tracer},
@@ -7,21 +8,18 @@ use tracing::Subscriber;
 use tracing_opentelemetry::OpenTelemetryLayer;
 use tracing_subscriber::{registry::LookupSpan, Layer};
 
-pub fn layer<S>(resource: Resource) -> impl Layer<S>
+pub fn layer<S>(
+    endpoint: impl Into<String>,
+    resource: Resource,
+    sampler_ratio: f64,
+) -> impl Layer<S>
 where
     S: Subscriber + for<'span> LookupSpan<'span>,
 {
-    OpenTelemetryLayer::new(init_tracer(resource))
+    OpenTelemetryLayer::new(init_tracer(endpoint, resource, sampler_ratio))
 }
 
-fn init_tracer(resource: Resource) -> Tracer {
-    // https://opentelemetry.io/docs/specs/otel/configuration/sdk-environment-variables/
-    let sampler_ratio = std::env::var("OTEL_TRACES_SAMPLER_ARG")
-        .ok()
-        .and_then(|v| v.parse::<f64>().ok())
-        .unwrap_or(0.);
-
-    // TODO: construct tonic transport channel
+fn init_tracer(endpoint: impl Into<String>, resource: Resource, sampler_ratio: f64) -> Tracer {
     opentelemetry_otlp::new_pipeline()
         .tracing()
         .with_trace_config(
@@ -32,7 +30,11 @@ fn init_tracer(resource: Resource) -> Tracer {
                 .with_resource(resource),
         )
         .with_batch_config(BatchConfig::default())
-        .with_exporter(opentelemetry_otlp::new_exporter().tonic())
+        .with_exporter(
+            opentelemetry_otlp::new_exporter()
+                .tonic()
+                .with_endpoint(endpoint),
+        )
         .install_batch(runtime::Tokio)
         .unwrap()
 }