Adding Context implemenations for HeaderMap and MetadataMap (#115)

Author: swilcox3

Cargo.toml

@@ -25,6 +25,8 @@ prometheus = { version = "0.7", optional = true }
 rand = { version = "0.7", optional = true }
 serde = { version = "1.0", features = ["derive", "rc"], optional = true }
 bincode = { version = "1.2", optional = true }
+http = { version = "0.2.1", optional = true }
+tonic = { version = "0.2.1", optional = true }
 
 [dev-dependencies]
 criterion = "0.3.1"

examples/grpc/Cargo.toml

@@ -16,7 +16,7 @@ http = "0.2"
 tonic = "0.2"
 prost = "0.6"
 tokio = { version = "0.2", features = ["full"] }
-opentelemetry = { path = "../../" }
+opentelemetry = { path = "../../", features = ["tonic"] }
 opentelemetry-jaeger = { path = "../../opentelemetry-jaeger" }
 
 [build-dependencies]

examples/grpc/src/client.rs

@@ -4,7 +4,7 @@ use opentelemetry::api::{
     Context, HttpTextFormat, KeyValue, TraceContextExt, TraceContextPropagator, Tracer,
 };
 use opentelemetry::sdk::Sampler;
-use opentelemetry::{api, global, sdk};
+use opentelemetry::{global, sdk};
 
 pub mod hello_world {
     tonic::include_proto!("helloworld");
@@ -36,22 +36,6 @@ fn tracing_init() -> Result<(), Box<dyn std::error::Error>> {
     Ok(())
 }
 
-struct TonicMetadataMapCarrier<'a>(&'a mut tonic::metadata::MetadataMap);
-impl<'a> api::Carrier for TonicMetadataMapCarrier<'a> {
-    fn get(&self, key: &'static str) -> Option<&str> {
-        self.0.get(key).and_then(|metadata| metadata.to_str().ok())
-    }
-
-    fn set(&mut self, key: &'static str, value: String) {
-        if let Ok(key) = tonic::metadata::MetadataKey::from_bytes(key.to_lowercase().as_bytes()) {
-            self.0.insert(
-                key,
-                tonic::metadata::MetadataValue::from_str(&value).unwrap(),
-            );
-        }
-    }
-}
-
 #[tokio::main]
 async fn main() -> Result<(), Box<dyn std::error::Error>> {
     tracing_init()?;
@@ -63,7 +47,7 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
     let mut request = tonic::Request::new(HelloRequest {
         name: "Tonic".into(),
     });
-    propagator.inject_context(&cx, &mut TonicMetadataMapCarrier(request.metadata_mut()));
+    propagator.inject_context(&cx, request.metadata_mut());
 
     let response = client.say_hello(request).await?;
 

examples/grpc/src/server.rs

@@ -7,7 +7,7 @@ use opentelemetry::global;
 use opentelemetry::sdk::{self, Sampler};
 
 pub mod hello_world {
-    tonic::include_proto!("helloworld"); // The string specified here must match the proto package name
+    tonic::include_proto!("helloworld"); // The string specified here must match the proto package name.
 }
 
 #[derive(Debug, Default)]
@@ -20,7 +20,7 @@ impl Greeter for MyGreeter {
         request: Request<HelloRequest>, // Accept request of type HelloRequest
     ) -> Result<Response<HelloReply>, Status> {
         let propagator = api::TraceContextPropagator::new();
-        let parent_cx = propagator.extract(&HttpHeaderMapCarrier(request.metadata()));
+        let parent_cx = propagator.extract(request.metadata());
         let span = global::tracer("greeter").start_from_context("Processing reply", &parent_cx);
         span.set_attribute(KeyValue::new("request", format!("{:?}", request)));
 
@@ -59,19 +59,6 @@ fn tracing_init() -> Result<(), Box<dyn std::error::Error>> {
     Ok(())
 }
 
-struct HttpHeaderMapCarrier<'a>(&'a tonic::metadata::MetadataMap);
-impl<'a> api::Carrier for HttpHeaderMapCarrier<'a> {
-    fn get(&self, key: &'static str) -> Option<&str> {
-        self.0
-            .get(key.to_lowercase().as_str())
-            .and_then(|value| value.to_str().ok())
-    }
-
-    fn set(&mut self, _key: &'static str, _value: String) {
-        unimplemented!()
-    }
-}
-
 #[tokio::main]
 async fn main() -> Result<(), Box<dyn std::error::Error>> {
     tracing_init()?;

examples/http/Cargo.toml

@@ -14,5 +14,5 @@ path = "src/client.rs"
 [dependencies]
 hyper = "0.13"
 tokio = { version = "0.2", features = ["full"] }
-opentelemetry = { path = "../../" }
+opentelemetry = { path = "../../", features = ["http"] }
 opentelemetry-jaeger = { path = "../../opentelemetry-jaeger" }

examples/http/src/client.rs

@@ -2,17 +2,6 @@ use hyper::{body::Body, Client};
 use opentelemetry::api::{Context, HttpTextFormat, TraceContextExt, Tracer};
 use opentelemetry::{api, exporter::trace::stdout, global, sdk};
 
-struct ClientHeaderMapCarrier<'a>(&'a mut hyper::header::HeaderMap);
-impl<'a> api::Carrier for ClientHeaderMapCarrier<'a> {
-    fn get(&self, key: &'static str) -> Option<&str> {
-        self.0.get(key).and_then(|value| value.to_str().ok())
-    }
-
-    fn set(&mut self, key: &'static str, value: String) {
-        self.0.insert(key, value.parse().unwrap());
-    }
-}
-
 fn init_tracer() {
     // Create stdout exporter to be able to retrieve the collected spans.
     let exporter = stdout::Builder::default().init();
@@ -40,7 +29,7 @@ async fn main() -> std::result::Result<(), Box<dyn std::error::Error + Send + Sy
     let cx = Context::current_with_span(span);
 
     let mut req = hyper::Request::builder().uri("http://127.0.0.1:3000");
-    propagator.inject_context(&cx, &mut ClientHeaderMapCarrier(req.headers_mut().unwrap()));
+    propagator.inject_context(&cx, req.headers_mut().unwrap());
     let res = client.request(req.body(Body::from("Hallo!"))?).await?;
 
     cx.span().add_event(

examples/http/src/server.rs

@@ -7,20 +7,9 @@ use opentelemetry::{
 };
 use std::{convert::Infallible, net::SocketAddr};
 
-struct HttpHeaderMapCarrier<'a>(&'a hyper::header::HeaderMap);
-impl<'a> api::Carrier for HttpHeaderMapCarrier<'a> {
-    fn get(&self, key: &'static str) -> Option<&str> {
-        self.0.get(key).and_then(|value| value.to_str().ok())
-    }
-
-    fn set(&mut self, _key: &'static str, _value: String) {
-        unimplemented!()
-    }
-}
-
 async fn handle(req: Request<Body>) -> Result<Response<Body>, Infallible> {
     let propagator = api::TraceContextPropagator::new();
-    let parent_cx = propagator.extract(&HttpHeaderMapCarrier(req.headers()));
+    let parent_cx = propagator.extract(req.headers());
     let span = global::tracer("example/server").start_from_context("hello", &parent_cx);
     span.add_event("handling this...".to_string(), Vec::new());
 

src/api/context/propagation/composite_propagator.rs

@@ -151,7 +151,7 @@ mod tests {
 
         for (header_name, header_value) in test_data() {
             let mut carrier = HashMap::new();
-            carrier.insert(header_name, header_value.to_string());
+            carrier.insert(header_name.to_string(), header_value.to_string());
             assert_eq!(
                 composite_propagator.extract(&carrier).remote_span_context(),
                 Some(&SpanContext::new(

src/api/context/propagation/mod.rs

@@ -170,19 +170,59 @@ pub mod text_propagator;
 /// underlying struct like `HashMap`.
 pub trait Carrier {
     /// Get a value for a key from the underlying data.
-    fn get(&self, key: &'static str) -> Option<&str>;
+    fn get(&self, key: &str) -> Option<&str>;
     /// Add a key and value to the underlying.
-    fn set(&mut self, key: &'static str, value: String);
+    fn set(&mut self, key: &str, value: String);
 }
 
-impl<S: std::hash::BuildHasher> api::Carrier for HashMap<&'static str, String, S> {
+impl<S: std::hash::BuildHasher> api::Carrier for HashMap<String, String, S> {
     /// Get a value for a key from the HashMap.
-    fn get(&self, key: &'static str) -> Option<&str> {
+    fn get(&self, key: &str) -> Option<&str> {
         self.get(key).map(|v| v.as_str())
     }
 
     /// Set a key and value in the HashMap.
-    fn set(&mut self, key: &'static str, value: String) {
-        self.insert(key, value);
+    fn set(&mut self, key: &str, value: String) {
+        self.insert(String::from(key), value);
+    }
+}
+
+#[cfg(feature = "http")]
+impl api::Carrier for http::HeaderMap {
+    /// Get a value for a key from the HeaderMap.  If the value is not valid ASCII, returns None.
+    fn get(&self, key: &str) -> Option<&str> {
+        match self.get(key) {
+            Some(val) => match val.to_str() {
+                Ok(ascii) => Some(ascii),
+                Err(_) => None,
+            },
+            None => None,
+        }
+    }
+
+    /// Set a key and value in the HeaderMap.  Does nothing if the key or value are not valid inputs.
+    fn set(&mut self, key: &str, value: String) {
+        if let Ok(name) = http::header::HeaderName::from_bytes(key.as_bytes()) {
+            if let Ok(val) = http::header::HeaderValue::from_str(&value) {
+                self.insert(name, val);
+            }
+        }
+    }
+}
+
+#[cfg(feature = "tonic")]
+impl api::Carrier for tonic::metadata::MetadataMap {
+    /// Get a value for a key from the MetadataMap.  If the value can't be converted to &str, returns None
+    fn get(&self, key: &str) -> Option<&str> {
+        self.get(key).and_then(|metadata| metadata.to_str().ok())
+    }
+
+    /// Set a key and value in the MetadataMap.  Does nothing if the key or value are not valid inputs
+    fn set(&mut self, key: &str, value: String) {
+        if let Ok(key) = tonic::metadata::MetadataKey::from_bytes(key.to_lowercase().as_bytes()) {
+            if let Ok(val) = tonic::metadata::MetadataValue::from_str(&value) {
+                self.insert(key, val);
+            }
+        }
     }
 }

src/api/correlation/mod.rs

@@ -20,7 +20,7 @@
 //!
 //! // Example correlation value passed in externally via http headers
 //! let mut headers = HashMap::new();
-//! headers.insert("Correlation-Context", "user_id=1".to_string());
+//! headers.insert("Correlation-Context".to_string(), "user_id=1".to_string());
 //!
 //! let propagator = CorrelationContextPropagator::new();
 //! // can extract from any type that impls `Carrier`, usually an HTTP header map