chore: update dependency

Cargo.toml

@@ -79,7 +79,7 @@ tracing-subscriber = { version = "0.3", features = [
 ] }
 tracing-appender = "0.2"
 tracing-error = { version = "0.2" }
-tracing-opentelemetry = { version = "0.28" }
+tracing-opentelemetry = { version = "0.29" }
 
 # Database
 sea-orm = { version = "1.1", features = [
@@ -121,10 +121,10 @@ rune = { version = "0.13", features = ["tokio"] }
 rune-modules = { version = "0.13", features = ["full"] }
 
 # Telemetry
-opentelemetry = { version = "0.27", features = ["metrics"] }
-opentelemetry-otlp = { version = "0.27", features = ["metrics"] }
-opentelemetry_sdk = { version = "0.27", features = ["rt-tokio"] }
-opentelemetry-appender-tracing = { version = "0.27" }
+opentelemetry = { version = "0.28", features = ["metrics"] }
+opentelemetry-otlp = { version = "0.28", features = ["metrics", "grpc-tonic"] }
+opentelemetry_sdk = { version = "0.28", features = ["rt-tokio"] }
+opentelemetry-appender-tracing = { version = "0.28" }
 sysinfo = { version = "0.33" }
 
 # Miscellaneous

crates/telemetry/src/lib.rs

@@ -12,8 +12,7 @@ use opentelemetry_sdk::Resource;
 use tracing::{info, warn};
 
 pub(crate) static RESOURCE: Lazy<Resource> = Lazy::new(|| {
-    let pairs = vec![KeyValue::new("service.name", "cdsctf")];
-    Resource::new(pairs)
+    Resource::builder().with_service_name("cdsctf").build()
 });
 
 pub(crate) fn get_export_config() -> ExportConfig {

crates/telemetry/src/logger/mod.rs

@@ -2,15 +2,15 @@ use anyhow::anyhow;
 use once_cell::sync::OnceCell;
 use opentelemetry_appender_tracing::layer::OpenTelemetryTracingBridge;
 use opentelemetry_otlp::{LogExporter, WithExportConfig};
-use opentelemetry_sdk::logs::{Logger, LoggerProvider};
+use opentelemetry_sdk::logs::{SdkLogger, SdkLoggerProvider};
 
-pub static PROVIDER: OnceCell<LoggerProvider> = OnceCell::new();
+pub static PROVIDER: OnceCell<SdkLoggerProvider> = OnceCell::new();
 
-pub fn get_provider() -> Option<LoggerProvider> {
+pub fn get_provider() -> Option<SdkLoggerProvider> {
     PROVIDER.get().map(|p| p.to_owned())
 }
 
-pub fn get_tracing_layer() -> Option<OpenTelemetryTracingBridge<LoggerProvider, Logger>> {
+pub fn get_tracing_layer() -> Option<OpenTelemetryTracingBridge<SdkLoggerProvider, SdkLogger>> {
     get_provider().map(|p| OpenTelemetryTracingBridge::new(&p))
 }
 
@@ -21,8 +21,8 @@ pub fn init() -> Result<(), anyhow::Error> {
         .build()
         .map_err(|_| anyhow!("Failed to initialize log."))?;
 
-    let logger_provider = LoggerProvider::builder()
-        .with_batch_exporter(log_exporter, opentelemetry_sdk::runtime::Tokio)
+    let logger_provider = SdkLoggerProvider::builder()
+        .with_batch_exporter(log_exporter)
         .with_resource(crate::RESOURCE.clone())
         .build();
 
@@ -33,16 +33,16 @@ pub fn init() -> Result<(), anyhow::Error> {
 
 pub async fn shutdown() -> Result<(), anyhow::Error> {
     tokio::task::spawn_blocking(move || {
-        for r in get_provider().unwrap().force_flush() {
-            if let Err(e) = r {
-                println!("unable to fully flush logs: {e}");
-            }
+        if let Err(e) = get_provider().unwrap().force_flush() {
+            println!("unable to fully flush logs: {:?}", e);
         }
     })
     .await?;
 
     tokio::task::spawn_blocking(move || {
-        get_provider().unwrap().shutdown().unwrap();
+        if let Err(e) = get_provider().unwrap().shutdown() {
+            println!("unable to shutdown telemetry logger provider: {:?}", e);
+        }
     })
     .await?;
 

crates/telemetry/src/meter/mod.rs

@@ -4,12 +4,9 @@ use std::{borrow::Cow, time::Duration};
 
 use anyhow::anyhow;
 use once_cell::sync::{Lazy, OnceCell};
-use opentelemetry::{InstrumentationScope, KeyValue, global, metrics::Meter};
+use opentelemetry::{global, metrics::Meter, InstrumentationScope};
 use opentelemetry_otlp::{MetricExporter, WithExportConfig};
-use opentelemetry_sdk::{
-    Resource,
-    metrics::{PeriodicReader, SdkMeterProvider, Temporality},
-};
+use opentelemetry_sdk::metrics::{PeriodicReader, SdkMeterProvider, Temporality};
 
 pub static PROVIDER: OnceCell<SdkMeterProvider> = OnceCell::new();
 
@@ -31,7 +28,7 @@ pub fn init() -> Result<(), anyhow::Error> {
 
     let meter_provider = SdkMeterProvider::builder()
         .with_reader(
-            PeriodicReader::builder(metric_exporter, opentelemetry_sdk::runtime::Tokio)
+            PeriodicReader::builder(metric_exporter)
                 .with_interval(Duration::from_secs(3))
                 .build(),
         )

crates/telemetry/src/tracer/mod.rs

@@ -7,11 +7,11 @@ use opentelemetry::{
     trace::TracerProvider as TracerProviderTraits,
 };
 use opentelemetry_otlp::{SpanExporter, WithExportConfig};
-use opentelemetry_sdk::trace::{Tracer, TracerProvider};
+use opentelemetry_sdk::trace::{Tracer, SdkTracerProvider};
 
-static PROVIDER: OnceCell<TracerProvider> = OnceCell::new();
+static PROVIDER: OnceCell<SdkTracerProvider> = OnceCell::new();
 
-pub fn get_provider() -> Option<TracerProvider> {
+pub fn get_provider() -> Option<SdkTracerProvider> {
     PROVIDER.get().map(|p| p.to_owned())
 }
 
@@ -34,8 +34,8 @@ pub fn init() -> Result<(), anyhow::Error> {
         .build()
         .map_err(|_| anyhow!("Failed to initialize span."))?;
 
-    let tracer_provider = TracerProvider::builder()
-        .with_batch_exporter(span_exporter, opentelemetry_sdk::runtime::Tokio)
+    let tracer_provider = SdkTracerProvider::builder()
+        .with_batch_exporter(span_exporter)
         .with_resource(crate::RESOURCE.clone())
         .build();
 
@@ -47,15 +47,17 @@ pub fn init() -> Result<(), anyhow::Error> {
 
 pub async fn shutdown() -> Result<(), anyhow::Error> {
     tokio::task::spawn_blocking(move || {
-        for r in get_provider().unwrap().force_flush() {
-            if let Err(e) = r {
-                println!("unable to fully flush traces: {e}");
-            }
+        if let Err(e) = get_provider().unwrap().force_flush() {
+            println!("unable to fully flush traces: {:?}", e);
         }
     })
     .await?;
 
-    global::shutdown_tracer_provider();
+    tokio::task::spawn_blocking(move || {
+        if let Err(e) = get_provider().unwrap().shutdown() {
+            println!("unable to shutdown telemetry tracer provider: {:?}", e);
+        }
+    }).await?;
 
     Ok(())
 }