chore(deps): Update to OpenTelemetry 0.14

Author: notheotherben

Cargo.toml

@@ -31,8 +31,8 @@ bytes = "1"
 chrono = "0.4"
 http = "0.2"
 thiserror = "1"
-opentelemetry = "0.13"
-opentelemetry-semantic-conventions = "0.5"
+opentelemetry = "0.14"
+opentelemetry-semantic-conventions = "0.6"
 reqwest = { version = "0.11", optional = true, default-features = false }
 serde = { version = "1", features = ["derive"] }
 serde_json = "1"
@@ -43,10 +43,10 @@ once_cell = "1"
 async-std = { version = "1.9.0", features = ["attributes"] }
 backtrace = "0.3.56"
 env_logger = "0.8.3"
-opentelemetry = { version = "0.13.0", features = ["rt-tokio"] }
+opentelemetry = { version = "0.14.0", features = ["rt-tokio"] }
 opentelemetry-application-insights = { path = ".", features = ["reqwest-client", "reqwest-blocking-client"] }
 test-case = "1.1.0"
-tokio = { version = "1.4.0", features = ["rt", "macros", "process", "time"] }
+tokio = { version = "1.6.0", features = ["rt", "macros", "process", "time"] }
 version-sync = "0.9.2"
 
 [package.metadata.docs.rs]

examples/opentelemetry.rs

@@ -14,7 +14,7 @@ use tokio::time::sleep;
 
 async fn spawn_children(n: u32, process_name: String) {
     let tracer = global::tracer("spawn_children");
-    let span = tracer.start("spawn_children");
+    let mut span = tracer.start("spawn_children");
     span.set_attribute(Key::new("n").i64(n.into()));
     span.set_attribute(Key::new("process_name").string(process_name.clone()));
     let cx = Context::current_with_span(span);
@@ -27,7 +27,7 @@ async fn spawn_children(n: u32, process_name: String) {
 
 async fn spawn_child_process(process_name: &str) {
     let tracer = global::tracer("spawn_child_process");
-    let span = tracer
+    let mut span = tracer
         .span_builder("spawn_child_process")
         .with_kind(SpanKind::Client)
         .start(&tracer);
@@ -54,7 +54,7 @@ async fn spawn_child_process(process_name: &str) {
 
 async fn run_in_child_process() {
     let tracer = global::tracer("run_in_child_process");
-    let span = tracer.start("run_in_child_process");
+    let mut span = tracer.start("run_in_child_process");
     span.add_event("leaf fn".into(), vec![]);
     sleep(Duration::from_millis(50)).await
 }

src/convert.rs

@@ -5,6 +5,7 @@ use opentelemetry::{
     trace::{SpanId, TraceId},
 };
 use std::time::{Duration, SystemTime};
+use std::sync::Arc;
 
 pub(crate) fn trace_id_to_string(trace_id: TraceId) -> String {
     format!("{:032x}", trace_id.to_u128())
@@ -33,16 +34,27 @@ pub(crate) fn time_to_string(time: SystemTime) -> String {
 
 pub(crate) fn attrs_to_properties(
     attributes: &EvictedHashMap,
-    resource: &Resource,
+    resource: Option<Arc<Resource>>,
 ) -> Option<Properties> {
-    Some(
-        attributes
-            .iter()
-            .map(|(k, v)| (k.as_str().into(), v.into()))
-            .chain(resource.iter().map(|(k, v)| (k.as_str().into(), v.into())))
-            .collect(),
-    )
-    .filter(|x: &Properties| !x.is_empty())
+    let properties = attributes
+        .iter()
+        .map(|(k, v)| (k.as_str().into(), v.into()));
+
+    if let Some(resource) = resource {
+        Some(
+            properties
+                .chain(resource.iter().map(|(k, v)| (k.as_str().into(), v.into())))
+                .collect(),
+        )
+        .filter(|x: &Properties| !x.is_empty())
+    } else {
+        Some(
+            properties.collect(),
+        )
+        .filter(|x: &Properties| !x.is_empty())
+    }
+
+
 }
 
 #[cfg(test)]

src/lib.rs

@@ -284,15 +284,20 @@ impl<C> PipelineBuilder<C> {
     ///     .install_simple();
     /// ```
     pub fn with_trace_config(self, config: sdk::trace::Config) -> Self {
-        let merged_resource = match self.config {
-            Some(base_config) => base_config.resource.merge(&config.resource),
-            None => (*config.resource).clone(),
+        let config = match config.resource {
+            Some(ref resource) => {
+                let merged_resource = match self.config {
+                    Some(base_config) => base_config.resource.map(|r| r.merge(&resource)).unwrap_or(resource.as_ref().clone()),
+                    None => resource.as_ref().clone(),
+                };
+
+                Some(config.with_resource(merged_resource))
+            },
+            None => Some(config)
         };
 
-        let config = config.with_resource(merged_resource);
-
         PipelineBuilder {
-            config: Some(config),
+            config: config,
             ..self
         }
     }
@@ -313,9 +318,10 @@ impl<C> PipelineBuilder<C> {
     /// ```
     pub fn with_service_name<T: Into<Cow<'static, str>>>(self, name: T) -> Self {
         let config = self.config.unwrap_or_default();
-        let merged_resource = config.resource.merge(&sdk::Resource::new(vec![
+        let new_resource = sdk::Resource::new(vec![
             semcov::resource::SERVICE_NAME.string(name),
-        ]));
+        ]);
+        let merged_resource = config.resource.as_ref().map(|r| r.merge(&new_resource)).unwrap_or(new_resource);
         let config = config.with_resource(merged_resource);
 
         PipelineBuilder {
@@ -359,7 +365,7 @@ where
         let config = self.config.take();
         let exporter = self.init_exporter();
         let mut builder =
-            sdk::trace::TracerProvider::builder().with_default_batch_exporter(exporter, runtime);
+            sdk::trace::TracerProvider::builder().with_batch_exporter(exporter, runtime);
         if let Some(config) = config {
             builder = builder.with_config(config);
         }
@@ -441,7 +447,7 @@ impl<C> Exporter<C> {
     }
 
     fn create_envelopes(&self, span: SpanData) -> Vec<Envelope> {
-        let mut result = Vec::with_capacity(1 + span.message_events.len());
+        let mut result = Vec::with_capacity(1 + span.events.len());
 
         let (data, tags, name) = match span.span_kind {
             SpanKind::Server | SpanKind::Consumer => {
@@ -472,7 +478,7 @@ impl<C> Exporter<C> {
             data: Some(data),
         });
 
-        for event in span.message_events.iter() {
+        for event in span.events.iter() {
             let (data, name) = match event.name.as_ref() {
                 "exception" => (
                     Data::Exception(event.into()),
@@ -565,7 +571,7 @@ impl From<&SpanData> for RequestData {
             success: span.status_code != StatusCode::Error,
             source: None,
             url: None,
-            properties: attrs_to_properties(&span.attributes, span.resource.as_ref()),
+            properties: attrs_to_properties(&span.attributes, span.resource.clone()),
         };
 
         if let Some(method) = span.attributes.get(&semcov::trace::HTTP_METHOD) {
@@ -631,7 +637,7 @@ impl From<&SpanData> for RemoteDependencyData {
             data: None,
             target: None,
             type_: None,
-            properties: attrs_to_properties(&span.attributes, span.resource.as_ref()),
+            properties: attrs_to_properties(&span.attributes, span.resource.clone()),
         };
 
         if let Some(status_code) = span.attributes.get(&semcov::trace::HTTP_STATUS_CODE) {

src/models/sanitize.rs

@@ -18,6 +18,12 @@ macro_rules! limited_len_string {
             }
         }
 
+        impl <'a> From<std::borrow::Cow<'a, str>> for $name {
+            fn from(s: std::borrow::Cow<'a, str>) -> Self {
+                Self(String::from(&s[0..std::cmp::min(s.len(), $len)]))
+            }
+        }
+
         impl From<&opentelemetry::Value> for $name {
             fn from(v: &opentelemetry::Value) -> Self {
                 v.as_str().into_owned().into()