Merge pull request #2437 from calebschoepp/trace-more-host-components

Trace some more host components

Author: calebschoepp

Cargo.lock

@@ -17,10 +17,14 @@ spin-expressions = { path = "../expressions", optional = true }
 spin-locked-app = { path = "../locked-app" }
 spin-outbound-networking = { path = "../outbound-networking" }
 spin-world = { path = "../world", optional = true }
+spin-telemetry = { path = "../telemetry" }
 terminal = { path = "../terminal" }
 tracing = { workspace = true }
 url = "2.2.1"
 
 [features]
 default = ["runtime"]
 runtime = ["dep:spin-app", "dep:spin-core", "dep:spin-expressions", "dep:spin-world"]
+
+[lints]
+workspace = true

crates/outbound-http/Cargo.toml

@@ -1,12 +1,13 @@
 use anyhow::Result;
-use http::HeaderMap;
+use http::{HeaderMap, Uri};
 use reqwest::Client;
 use spin_core::async_trait;
 use spin_outbound_networking::{AllowedHostsConfig, OutboundUrl};
 use spin_world::v1::{
     http as outbound_http,
     http_types::{Headers, HttpError, Method, Request, Response},
 };
+use tracing::{field::Empty, instrument, Level};
 
 /// A very simple implementation for outbound HTTP requests.
 #[derive(Default, Clone)]
@@ -38,8 +39,28 @@ impl OutboundHttp {
 
 #[async_trait]
 impl outbound_http::Host for OutboundHttp {
+    #[instrument(name = "spin_outbound_http.send_request", skip_all, err(level = Level::INFO),
+        fields(otel.kind = "client", url.full = Empty, http.request.method = Empty,
+        http.response.status_code = Empty, otel.name = Empty, server.address = Empty, server.port = Empty))]
     async fn send_request(&mut self, req: Request) -> Result<Result<Response, HttpError>> {
         Ok(async {
+            let current_span = tracing::Span::current();
+            let method = format!("{:?}", req.method)
+                .strip_prefix("Method::")
+                .unwrap_or("_OTHER")
+                .to_uppercase();
+            current_span.record("otel.name", method.clone());
+            current_span.record("url.full", req.uri.clone());
+            current_span.record("http.request.method", method);
+            if let Ok(uri) = req.uri.parse::<Uri>() {
+                if let Some(authority) = uri.authority() {
+                    current_span.record("server.address", authority.host());
+                    if let Some(port) = authority.port() {
+                        current_span.record("server.port", port.as_u16());
+                    }
+                }
+            }
+
             tracing::log::trace!("Attempting to send outbound HTTP request to {}", req.uri);
             if !self
                 .is_allowed(&req.uri)
@@ -63,7 +84,8 @@ impl outbound_http::Host for OutboundHttp {
 
             let req_url = reqwest::Url::parse(&abs_url).map_err(|_| HttpError::InvalidUrl)?;
 
-            let headers = request_headers(req.headers).map_err(|_| HttpError::RuntimeError)?;
+            let mut headers = request_headers(req.headers).map_err(|_| HttpError::RuntimeError)?;
+            spin_telemetry::inject_trace_context(&mut headers);
             let body = req.body.unwrap_or_default().to_vec();
 
             if !req.params.is_empty() {
@@ -82,6 +104,7 @@ impl outbound_http::Host for OutboundHttp {
                 .await
                 .map_err(log_reqwest_error)?;
             tracing::log::trace!("Returning response from outbound request to {}", req.uri);
+            current_span.record("http.response.status_code", resp.status().as_u16());
             response_from_reqwest(resp).await
         }
         .await)

crates/outbound-http/src/host_impl.rs

@@ -18,3 +18,6 @@ spin-outbound-networking = { path = "../outbound-networking" }
 table = { path = "../table" }
 tokio = { version = "1", features = ["sync"] }
 tracing = { workspace = true }
+
+[lints]
+workspace = true

crates/outbound-mqtt/Cargo.toml

@@ -8,6 +8,7 @@ use spin_core::{async_trait, wasmtime::component::Resource};
 use spin_world::v2::mqtt::{self as v2, Connection as MqttConnection, Error, Qos};
 
 pub use host_component::OutboundMqttComponent;
+use tracing::{instrument, Level};
 
 pub struct OutboundMqtt {
     allowed_hosts: spin_outbound_networking::AllowedHostsConfig,
@@ -59,6 +60,7 @@ impl v2::Host for OutboundMqtt {}
 
 #[async_trait]
 impl v2::HostConnection for OutboundMqtt {
+    #[instrument(name = "spin_outbound_mqtt.open_connection", skip(self, password), err(level = Level::INFO), fields(otel.kind = "client"))]
     async fn open(
         &mut self,
         address: String,
@@ -80,6 +82,14 @@ impl v2::HostConnection for OutboundMqtt {
         .await
     }
 
+    /// Publish a message to the MQTT broker.
+    ///
+    /// OTEL trace propagation is not directly supported in MQTT V3. You will need to embed the
+    /// current trace context into the payload yourself.
+    /// https://w3c.github.io/trace-context-mqtt/#mqtt-v3-recommendation.
+    #[instrument(name = "spin_outbound_mqtt.publish", skip(self, connection, payload), err(level = Level::INFO),
+        fields(otel.kind = "producer", otel.name = format!("{} publish", topic), messaging.operation = "publish",
+        messaging.system = "mqtt"))]
     async fn publish(
         &mut self,
         connection: Resource<MqttConnection>,