Update otel

Author: lucemans

.cursor/rules/rust.mdc

@@ -9,3 +9,5 @@ globs: **.rs
 ---
 
 This Rust project uses the async-std runtime, the anyhow error handling crate, the Poem HTTP framework, and rustls-tls for secure TLS. Assume these dependencies are available and imported when generating code.
+
+This project is a monorepo, the rust code can be found in the `engine/` folder.

engine/src/main.rs

@@ -28,19 +28,13 @@ use tracing_subscriber::prelude::*;
 #[async_std::main]
 async fn main() {
     dotenvy::dotenv().ok();
-    // tracing_log::LogTracer::init().expect("Failed to initialize logger");
-
-    // let exporter = opentelemetry_otlp::SpanExporter::builder()
-    //     .with_http()
-    //     .with_endpoint("http://localhost:4317")
-    //     .build()
-    //     // .install_batch(opentelemetry_sdk::runtime::AsyncStd)
-    //     .expect("Couldn't create OTLP tracer");
 
     let otlp_endpoint = env::var("OTLP_ENDPOINT").ok();
 
     if let Some(endpoint) = otlp_endpoint {
         info!("Starting Edgerouter with OTLP tracing");
+        
+        // Set up propagator for trace context
         opentelemetry::global::set_text_map_propagator(TraceContextPropagator::new());
 
         let exporter = opentelemetry_otlp::SpanExporter::builder()
@@ -56,6 +50,7 @@ async fn main() {
             .with_attribute(KeyValue::new("host.name", hostname))
             .build();
 
+        // Use a simple tracer provider configuration
         let trace_provider = opentelemetry_sdk::trace::SdkTracerProvider::builder()
             .with_resource(resource)
             .with_batch_exporter(exporter)
@@ -65,17 +60,20 @@ async fn main() {
 
         let tracer = trace_provider.tracer("edgeserver");
 
+        // Simple telemetry layer
         let telemetry_layer = tracing_opentelemetry::layer()
-            .with_tracer(tracer.clone())
-            .with_error_fields_to_exceptions(true)
-            .with_tracked_inactivity(true);
+            .with_tracer(tracer);
 
-        let fmt_layer = tracing_subscriber::fmt::layer().with_span_events(tracing_subscriber::fmt::format::FmtSpan::CLOSE);
+        // Create a formatting layer with span closure events
+        let fmt_layer = tracing_subscriber::fmt::layer()
+            .with_span_events(tracing_subscriber::fmt::format::FmtSpan::CLOSE);
 
+        // Set up filter for relevant components
         let filter = tracing_subscriber::EnvFilter::from_default_env()
             .add_directive("poem=info".parse().unwrap())
             .add_directive("edgeserver=debug".parse().unwrap());
 
+        // Register layers with the subscriber
         tracing_subscriber::registry()
             .with(filter)
             .with(fmt_layer)

engine/src/middlewares/auth.rs

@@ -7,7 +7,6 @@ use poem_openapi::{
     ApiExtractor, ApiExtractorType, ExtractParamOptions,
 };
 use tracing::{info, info_span, Instrument};
-use tracing_opentelemetry::OpenTelemetrySpanExt;
 
 use crate::{
     models::{keys::Key, session::Session, team::Team},
@@ -38,15 +37,10 @@ impl<'a> ApiExtractor<'a> for UserAuth {
         body: &mut RequestBody,
         _param_opts: ExtractParamOptions<Self::ParamType>,
     ) -> Result<Self> {
-        // Get current OpenTelemetry context to propagate
-        let parent_cx = Context::current();
-
-        // Create auth span with proper parent context
-        let auth_span = info_span!("auth");
-        auth_span.set_parent(parent_cx);
-
-        // Run the authentication logic within the auth span
-        let auth_result = async move {
+        let span = info_span!("auth");
+        
+        // Use instrument to track the auth span
+        async {
             let state = <Data<&State> as FromRequest>::from_request(req, body).await?;
             let state = state.0;
 
@@ -120,10 +114,8 @@ impl<'a> ApiExtractor<'a> for UserAuth {
 
             Err(HttpError::Unauthorized.into())
         }
-        .instrument(auth_span)
-        .await;
-
-        auth_result
+        .instrument(span)
+        .await
     }
 
     fn register(registry: &mut Registry) {
@@ -177,15 +169,10 @@ impl UserAuth {
         &self,
         team_id: impl AsRef<str> + Debug,
     ) -> Result<(), HttpError> {
-        // Get current OpenTelemetry context to propagate
-        let parent_cx = Context::current();
-
-        // Create span with proper parent context
-        let member_span = info_span!("required_member_of", team_id = ?team_id);
-        member_span.set_parent(parent_cx);
-
-        // Each request should have its own context path
-        async move {
+        let span = info_span!("required_member_of", team_id = ?team_id);
+        
+        // Use instrument to track the span
+        async {
             match self {
                 UserAuth::User(session, state) => {
                     if !Team::is_member(&state, &team_id, &session.user_id)
@@ -203,22 +190,18 @@ impl UserAuth {
                 UserAuth::None(_) => Err(HttpError::Unauthorized),
             }
         }
-        .instrument(member_span)
+        .instrument(span)
         .await
     }
 
     pub async fn verify_access_to(
         &self,
         resource: &impl AccessibleResource,
     ) -> Result<(), HttpError> {
-        // Get current OpenTelemetry context to propagate
-
-        // Create span with proper parent context
-        let access_span = info_span!("verify_access_to", resource = ?resource);
-        access_span.set_parent(Context::current());
-
-        // Each request should have its own context path
-        async move {
+        let span = info_span!("verify_access_to", resource = ?resource);
+        
+        // Use instrument to track the span
+        async {
             match self {
                 UserAuth::User(session, state) => match resource
                     .has_access(state, "user", &session.user_id)
@@ -241,7 +224,7 @@ impl UserAuth {
                 UserAuth::None(_) => Err(HttpError::Unauthorized),
             }
         }
-        .instrument(access_span)
+        .instrument(span)
         .await
     }
 }

engine/src/middlewares/tracing.rs

@@ -2,7 +2,7 @@ use std::sync::Arc;
 
 use opentelemetry::{
     global,
-    trace::{FutureExt, Span, SpanKind, Tracer, TraceContextExt},
+    trace::{Span, SpanKind, Tracer, TraceContextExt},
     Context, Key, KeyValue,
 };
 use opentelemetry_http::HeaderExtractor;
@@ -68,11 +68,6 @@ where
             .map(|addr| addr.to_string())
             .unwrap_or_else(|| req.remote_addr().to_string());
 
-        // Extract parent context from request headers if present
-        let parent_cx = global::get_text_map_propagator(|propagator| {
-            propagator.extract(&HeaderExtractor(req.headers()))
-        });
-
         // Prepare span attributes
         let mut attributes = Vec::new();
         attributes.push(KeyValue::new(
@@ -101,99 +96,95 @@ where
         // Get method for span name
         let method = req.method().to_string();
 
-        // Create an OpenTelemetry span
+        // Create a completely new span for this request
         let mut span = self
             .tracer
             .span_builder(format!("{} {}", method, req.uri()))
             .with_kind(SpanKind::Server)
             .with_attributes(attributes)
-            .start_with_context(&*self.tracer, &parent_cx);
-
+            .start_with_context(&*self.tracer, &Context::new()); // Use a new blank context
+            
         // Record request start event
         span.add_event("request.started".to_string(), vec![]);
 
         // Get trace ID for response header
         let trace_id = span.span_context().trace_id().to_string();
 
-        // Use FutureExt to maintain context across async boundaries
-        async move {
-            // Process the request with the inner endpoint
-            let res = self.inner.call(req).await;
-            
-            // Get current context with span
-            let cx = Context::current();
-            let span = cx.span();
-            
-            // Process the response
-            match res {
-                Ok(resp) => {
-                    let mut resp = resp.into_response();
-                    
-                    // Update span with path pattern if available
-                    if let Some(path_pattern) = resp.data::<PathPattern>() {
-                        const HTTP_PATH_PATTERN: Key = Key::from_static_str("http.path_pattern");
-                        span.update_name(format!("{} {}", method, path_pattern.0));
-                        span.set_attribute(KeyValue::new(
-                            HTTP_PATH_PATTERN,
-                            path_pattern.0.to_string(),
-                        ));
-                    }
-                    
-                    // Record successful completion
-                    span.add_event("request.completed".to_string(), vec![]);
-                    
-                    // Set response status
+        // Process the request with the inner endpoint
+        let res = self.inner.call(req).await;
+        
+        // Process the response
+        match res {
+            Ok(resp) => {
+                let mut resp = resp.into_response();
+                
+                // Update span with path pattern if available
+                if let Some(path_pattern) = resp.data::<PathPattern>() {
+                    const HTTP_PATH_PATTERN: Key = Key::from_static_str("http.path_pattern");
+                    span.update_name(format!("{} {}", method, path_pattern.0));
                     span.set_attribute(KeyValue::new(
-                        attribute::HTTP_RESPONSE_STATUS_CODE,
-                        resp.status().as_u16() as i64,
+                        HTTP_PATH_PATTERN,
+                        path_pattern.0.to_string(),
                     ));
-                    
-                    // Track content length if available
-                    if let Some(content_length) = resp.headers().typed_get::<headers::ContentLength>() {
-                        span.set_attribute(KeyValue::new(
-                            // attribute::HTTP_RESPONSE_BODY_SIZE,
-                            "http.response_body_size",
-                            content_length.0 as i64,
-                        ));
-                    }
-                    
-                    // Add trace ID to response headers
-                    resp.headers_mut().insert(
-                        "X-Trace-Id",
-                        HeaderValue::from_str(&trace_id)
-                            .unwrap_or_else(|_| HeaderValue::from_static("unknown")),
-                    );
-                    
-                    Ok(resp)
                 }
-                Err(err) => {
-                    // Update span with path pattern if error has it
-                    if let Some(path_pattern) = err.data::<PathPattern>() {
-                        const HTTP_PATH_PATTERN: Key = Key::from_static_str("http.path_pattern");
-                        span.update_name(format!("{} {}", method, path_pattern.0));
-                        span.set_attribute(KeyValue::new(
-                            HTTP_PATH_PATTERN,
-                            path_pattern.0.to_string(),
-                        ));
-                    }
-                    
-                    // Set error status code
+                
+                // Record successful completion
+                span.add_event("request.completed".to_string(), vec![]);
+                
+                // Set response status
+                span.set_attribute(KeyValue::new(
+                    attribute::HTTP_RESPONSE_STATUS_CODE,
+                    resp.status().as_u16() as i64,
+                ));
+                
+                // Track content length if available
+                if let Some(content_length) = resp.headers().typed_get::<headers::ContentLength>() {
+                    span.set_attribute(KeyValue::new(
+                        "http.response_body_size",
+                        content_length.0 as i64,
+                    ));
+                }
+                
+                // Add trace ID to response headers
+                resp.headers_mut().insert(
+                    "X-Trace-Id",
+                    HeaderValue::from_str(&trace_id)
+                        .unwrap_or_else(|_| HeaderValue::from_static("unknown")),
+                );
+                
+                // End the span
+                span.end();
+                
+                Ok(resp)
+            }
+            Err(err) => {
+                // Update span with path pattern if error has it
+                if let Some(path_pattern) = err.data::<PathPattern>() {
+                    const HTTP_PATH_PATTERN: Key = Key::from_static_str("http.path_pattern");
+                    span.update_name(format!("{} {}", method, path_pattern.0));
                     span.set_attribute(KeyValue::new(
-                        attribute::HTTP_RESPONSE_STATUS_CODE,
-                        err.status().as_u16() as i64,
+                        HTTP_PATH_PATTERN,
+                        path_pattern.0.to_string(),
                     ));
-                    
-                    // Record error event
-                    span.add_event(
-                        "request.error".to_string(),
-                        vec![KeyValue::new(attribute::EXCEPTION_MESSAGE, err.to_string())],
-                    );
-                    
-                    Err(err)
                 }
+                
+                // Set error status code
+                span.set_attribute(KeyValue::new(
+                    attribute::HTTP_RESPONSE_STATUS_CODE,
+                    err.status().as_u16() as i64,
+                ));
+                
+                // Record error event
+                span.add_event(
+                    "request.error".to_string(),
+                    vec![KeyValue::new(attribute::EXCEPTION_MESSAGE, err.to_string())],
+                );
+                
+                // End the span
+                span.end();
+                
+                Err(err)
             }
         }
-        .with_context(Context::current_with_span(span)) // Key to proper context propagation
-        .await
     }
 }

engine/src/server/mod.rs

@@ -302,4 +302,4 @@ fn polyfill_mime_type(mime: &str, file_name: &str) -> String {
     } else {
         mime.to_string()
     }
-}
+}

web/src/api/schema.gen.ts

@@ -1691,7 +1691,7 @@ export type components = {
          * Deployment
          * @example {
          *       "context": "{}",
-         *       "created_at": "2025-05-18T11:53:27.918210298+00:00",
+         *       "created_at": "2025-05-18T19:52:11.327096482+00:00",
          *       "deployment_id": "d_1234567890",
          *       "ipfs_cid": "Qm1234567890...",
          *       "site_id": "s_1234567890"
@@ -1764,13 +1764,13 @@ export type components = {
         /**
          * Key
          * @example {
-         *       "created_at": "2025-05-18T11:53:27.918285958+00:00",
+         *       "created_at": "2025-05-18T19:52:11.327172962+00:00",
          *       "created_by": "u_1234567890",
-         *       "expires_at": "2025-06-17T11:53:27.918286128+00:00",
+         *       "expires_at": "2025-06-17T19:52:11.327173112+00:00",
          *       "key_id": "k_site_12345678901234567890",
          *       "key_resource": "s_1234567890",
          *       "key_type": "site",
-         *       "last_used": "2025-05-18T11:53:27.918286058+00:00",
+         *       "last_used": "2025-05-18T19:52:11.327173042+00:00",
          *       "permissions": "TBD",
          *       "vanity": "4567890"
          *     }