Update KeyValue to avoid copying non-static string slices

opentelemetry-otlp/examples/basic-otlp-http/src/main.rs

@@ -3,7 +3,7 @@ use opentelemetry::{
     global,
     metrics::MetricsError,
     trace::{TraceContextExt, TraceError, Tracer, TracerProvider as _},
-    Key, KeyValue,
+    KeyValue,
 };
 use opentelemetry_appender_tracing::layer::OpenTelemetryTracingBridge;
 use opentelemetry_otlp::Protocol;
@@ -146,7 +146,7 @@ async fn main() -> Result<(), Box<dyn Error + Send + Sync + 'static>> {
         let span = cx.span();
         span.add_event(
             "Nice operation!".to_string(),
-            vec![Key::new("bogons").i64(100)],
+            vec![KeyValue::new("bogons", 100)],
         );
         span.set_attribute(KeyValue::new("another.key", "yes"));
 

opentelemetry-otlp/examples/basic-otlp/src/main.rs

@@ -5,7 +5,7 @@ use opentelemetry::metrics::MetricsError;
 use opentelemetry::trace::{TraceError, TracerProvider};
 use opentelemetry::{
     trace::{TraceContextExt, Tracer},
-    Key, KeyValue,
+    KeyValue,
 };
 use opentelemetry_appender_tracing::layer::OpenTelemetryTracingBridge;
 use opentelemetry_otlp::{ExportConfig, WithExportConfig};
@@ -136,7 +136,7 @@ async fn main() -> Result<(), Box<dyn Error + Send + Sync + 'static>> {
         let span = cx.span();
         span.add_event(
             "Nice operation!".to_string(),
-            vec![Key::new("bogons").i64(100)],
+            vec![KeyValue::new("bogons", 100)],
         );
         span.set_attribute(KeyValue::new("another.key", "yes"));
 

opentelemetry-otlp/tests/integration_test/tests/traces.rs

@@ -41,7 +41,7 @@ pub async fn traces() -> Result<(), Box<dyn Error + Send + Sync + 'static>> {
         let span = cx.span();
         span.add_event(
             "Nice operation!".to_string(),
-            vec![Key::new("bogons").i64(100)],
+            vec![KeyValue::new("bogons", 100)],
         );
         span.set_attribute(KeyValue::new(ANOTHER_KEY, "yes"));
 

opentelemetry-proto/src/transform/common.rs

@@ -112,8 +112,8 @@
     #[derive(Default, Debug)]
     pub struct Attributes(pub ::std::vec::Vec<crate::proto::tonic::common::v1::KeyValue>);
 
-    impl From<Vec<opentelemetry::KeyValue>> for Attributes {
-        fn from(kvs: Vec<opentelemetry::KeyValue>) -> Self {
+    impl From<Vec<opentelemetry::KeyValue<'static>>> for Attributes {
+        fn from(kvs: Vec<opentelemetry::KeyValue<'static>>) -> Self {
             Attributes(
                 kvs.into_iter()
                     .map(|api_kv| KeyValue {
@@ -139,19 +139,19 @@
         }
     }
 
-    impl From<Value> for AnyValue {
+    impl From<Value<'static>> for AnyValue {
         fn from(value: Value) -> Self {
             AnyValue {
                 value: match value {
-                    Value::Bool(val) => Some(any_value::Value::BoolValue(val)),
-                    Value::I64(val) => Some(any_value::Value::IntValue(val)),
-                    Value::F64(val) => Some(any_value::Value::DoubleValue(val)),
+                    Value::Bool(val) => Some(any_value::Value::BoolValue(*val)),
+                    Value::I64(val) => Some(any_value::Value::IntValue(*val)),
+                    Value::F64(val) => Some(any_value::Value::DoubleValue(*val)),
                     Value::String(val) => Some(any_value::Value::StringValue(val.to_string())),
                     Value::Array(array) => Some(any_value::Value::ArrayValue(match array {
-                        Array::Bool(vals) => array_into_proto(vals),
-                        Array::I64(vals) => array_into_proto(vals),
-                        Array::F64(vals) => array_into_proto(vals),
-                        Array::String(vals) => array_into_proto(vals),
+                        Array::Bool(vals) => array_into_proto(vals.to_vec()),
+                        Array::I64(vals) => array_into_proto(vals.to_vec()),
+                        Array::F64(vals) => array_into_proto(vals.to_vec()),
+                        Array::String(vals) => array_into_proto(vals.to_vec()),
                     })),
                 },
             }
@@ -160,7 +160,7 @@
 
     fn array_into_proto<T>(vals: Vec<T>) -> ArrayValue
     where
-        Value: From<T>,
+        Value<'static>: From<T>,
     {
         let values = vals
             .into_iter()

opentelemetry-proto/src/transform/metrics.rs

@@ -73,17 +73,17 @@
         }
     }
 
-    impl From<(&Key, &Value)> for KeyValue {
-        fn from(kv: (&Key, &Value)) -> Self {
+    impl From<(&Key, &Value<'static>)> for KeyValue {
+        fn from(kv: (&Key, &Value<'static>)) -> Self {
             KeyValue {
                 key: kv.0.to_string(),
                 value: Some(kv.1.clone().into()),
             }
         }
     }
 
-    impl From<&opentelemetry::KeyValue> for KeyValue {
-        fn from(kv: &opentelemetry::KeyValue) -> Self {
+    impl From<&opentelemetry::KeyValue<'static>> for KeyValue {
+        fn from(kv: &opentelemetry::KeyValue<'static>) -> Self {
             KeyValue {
                 key: kv.key.to_string(),
                 value: Some(kv.value.clone().into()),

opentelemetry-sdk/benches/trace.rs

@@ -2,7 +2,7 @@ use criterion::{criterion_group, criterion_main, Criterion};
 use futures_util::future::BoxFuture;
 use opentelemetry::{
     trace::{Span, Tracer, TracerProvider},
-    Key,
+    KeyValue,
 };
 use opentelemetry_sdk::{
     export::trace::{ExportResult, SpanData, SpanExporter},
@@ -16,42 +16,42 @@ fn criterion_benchmark(c: &mut Criterion) {
 
     trace_benchmark_group(c, "start-end-span-4-attrs", |tracer| {
         let mut span = tracer.start("foo");
-        span.set_attribute(Key::new("key1").bool(false));
-        span.set_attribute(Key::new("key2").string("hello"));
-        span.set_attribute(Key::new("key4").f64(123.456));
+        span.set_attribute(KeyValue::new("key1", false));
+        span.set_attribute(KeyValue::new("key2", "hello"));
+        span.set_attribute(KeyValue::new("key4", 123.456));
         span.end();
     });
 
     trace_benchmark_group(c, "start-end-span-8-attrs", |tracer| {
         let mut span = tracer.start("foo");
-        span.set_attribute(Key::new("key1").bool(false));
-        span.set_attribute(Key::new("key2").string("hello"));
-        span.set_attribute(Key::new("key4").f64(123.456));
-        span.set_attribute(Key::new("key11").bool(false));
-        span.set_attribute(Key::new("key12").string("hello"));
-        span.set_attribute(Key::new("key14").f64(123.456));
+        span.set_attribute(KeyValue::new("key1", false));
+        span.set_attribute(KeyValue::new("key2", "hello"));
+        span.set_attribute(KeyValue::new("key4", 123.456));
+        span.set_attribute(KeyValue::new("key11", false));
+        span.set_attribute(KeyValue::new("key12", "hello"));
+        span.set_attribute(KeyValue::new("key14", 123.456));
         span.end();
     });
 
     trace_benchmark_group(c, "start-end-span-all-attr-types", |tracer| {
         let mut span = tracer.start("foo");
-        span.set_attribute(Key::new("key1").bool(false));
-        span.set_attribute(Key::new("key2").string("hello"));
-        span.set_attribute(Key::new("key3").i64(123));
-        span.set_attribute(Key::new("key5").f64(123.456));
+        span.set_attribute(KeyValue::new("key1", false));
+        span.set_attribute(KeyValue::new("key2", "hello"));
+        span.set_attribute(KeyValue::new("key3", 123));
+        span.set_attribute(KeyValue::new("key5", 123.456));
         span.end();
     });
 
     trace_benchmark_group(c, "start-end-span-all-attr-types-2x", |tracer| {
         let mut span = tracer.start("foo");
-        span.set_attribute(Key::new("key1").bool(false));
-        span.set_attribute(Key::new("key2").string("hello"));
-        span.set_attribute(Key::new("key3").i64(123));
-        span.set_attribute(Key::new("key5").f64(123.456));
-        span.set_attribute(Key::new("key11").bool(false));
-        span.set_attribute(Key::new("key12").string("hello"));
-        span.set_attribute(Key::new("key13").i64(123));
-        span.set_attribute(Key::new("key15").f64(123.456));
+        span.set_attribute(KeyValue::new("key1", false));
+        span.set_attribute(KeyValue::new("key2", "hello"));
+        span.set_attribute(KeyValue::new("key3", 123));
+        span.set_attribute(KeyValue::new("key5", 123.456));
+        span.set_attribute(KeyValue::new("key11", false));
+        span.set_attribute(KeyValue::new("key12", "hello"));
+        span.set_attribute(KeyValue::new("key13", 123));
+        span.set_attribute(KeyValue::new("key15", 123.456));
         span.end();
     });
 }

opentelemetry-sdk/src/export/trace.rs

@@ -85,7 +85,7 @@ pub struct SpanData {
     /// Span end time
     pub end_time: SystemTime,
     /// Span attributes
-    pub attributes: Vec<KeyValue>,
+    pub attributes: Vec<KeyValue<'static>>,
     /// The number of attributes that were above the configured limit, and thus
     /// dropped.
     pub dropped_attributes_count: u32,

opentelemetry-sdk/src/logs/log_emitter.rs

@@ -46,7 +46,7 @@ impl opentelemetry::logs::LoggerProvider for LoggerProvider {
         name: impl Into<Cow<'static, str>>,
         version: Option<Cow<'static, str>>,
         schema_url: Option<Cow<'static, str>>,
-        attributes: Option<Vec<opentelemetry::KeyValue>>,
+        attributes: Option<Vec<opentelemetry::KeyValue<'static>>>,
     ) -> Logger {
         let name = name.into();
 

opentelemetry-sdk/src/metrics/data/mod.rs

@@ -97,7 +97,7 @@ impl<T: fmt::Debug + Send + Sync + 'static> Aggregation for Sum<T> {
 pub struct DataPoint<T> {
     /// Attributes is the set of key value pairs that uniquely identify the
     /// time series.
-    pub attributes: Vec<KeyValue>,
+    pub attributes: Vec<KeyValue<'static>>,
     /// The time when the time series was started.
     pub start_time: Option<SystemTime>,
     /// The time when the time series was recorded.
@@ -143,7 +143,7 @@ impl<T: fmt::Debug + Send + Sync + 'static> Aggregation for Histogram<T> {
 #[derive(Debug)]
 pub struct HistogramDataPoint<T> {
     /// The set of key value pairs that uniquely identify the time series.
-    pub attributes: Vec<KeyValue>,
+    pub attributes: Vec<KeyValue<'static>>,
     /// The time when the time series was started.
     pub start_time: SystemTime,
     /// The time when the time series was recorded.
@@ -210,7 +210,7 @@ impl<T: fmt::Debug + Send + Sync + 'static> Aggregation for ExponentialHistogram
 #[derive(Debug)]
 pub struct ExponentialHistogramDataPoint<T> {
     /// The set of key value pairs that uniquely identify the time series.
-    pub attributes: Vec<KeyValue>,
+    pub attributes: Vec<KeyValue<'static>>,
     /// When the time series was started.
     pub start_time: SystemTime,
     /// The time when the time series was recorded.
@@ -273,7 +273,7 @@ pub struct ExponentialBucket {
 pub struct Exemplar<T> {
     /// The attributes recorded with the measurement but filtered out of the
     /// time series' aggregated data.
-    pub filtered_attributes: Vec<KeyValue>,
+    pub filtered_attributes: Vec<KeyValue<'static>>,
     /// The time when the measurement was recorded.
     pub time: SystemTime,
     /// The measured value.

opentelemetry-sdk/src/metrics/instrument.rs

@@ -253,31 +253,31 @@ pub(crate) struct ResolvedMeasures<T> {
 }
 
 impl<T: Copy + 'static> SyncCounter<T> for ResolvedMeasures<T> {
-    fn add(&self, val: T, attrs: &[KeyValue]) {
+    fn add(&self, val: T, attrs: &[KeyValue<'_>]) {
         for measure in &self.measures {
             measure.call(val, attrs)
         }
     }
 }
 
 impl<T: Copy + 'static> SyncUpDownCounter<T> for ResolvedMeasures<T> {
-    fn add(&self, val: T, attrs: &[KeyValue]) {
+    fn add(&self, val: T, attrs: &[KeyValue<'_>]) {
         for measure in &self.measures {
             measure.call(val, attrs)
         }
     }
 }
 
 impl<T: Copy + 'static> SyncGauge<T> for ResolvedMeasures<T> {
-    fn record(&self, val: T, attrs: &[KeyValue]) {
+    fn record(&self, val: T, attrs: &[KeyValue<'_>]) {
         for measure in &self.measures {
             measure.call(val, attrs)
         }
     }
 }
 
 impl<T: Copy + 'static> SyncHistogram<T> for ResolvedMeasures<T> {
-    fn record(&self, val: T, attrs: &[KeyValue]) {
+    fn record(&self, val: T, attrs: &[KeyValue<'_>]) {
         for measure in &self.measures {
             measure.call(val, attrs)
         }
@@ -296,7 +296,7 @@ impl<T> Observable<T> {
 }
 
 impl<T: Copy + Send + Sync + 'static> AsyncInstrument<T> for Observable<T> {
-    fn observe(&self, measurement: T, attrs: &[KeyValue]) {
+    fn observe(&self, measurement: T, attrs: &[KeyValue<'_>]) {
         for measure in &self.measures {
             measure.call(measurement, attrs)
         }

opentelemetry-sdk/src/metrics/internal/aggregate.rs

@@ -18,14 +18,14 @@ pub(crate) fn is_under_cardinality_limit(size: usize) -> bool {
 
 /// Receives measurements to be aggregated.
 pub(crate) trait Measure<T>: Send + Sync + 'static {
-    fn call(&self, measurement: T, attrs: &[KeyValue]);
+    fn call(&self, measurement: T, attrs: &[KeyValue<'_>]);
 }
 
 impl<F, T> Measure<T> for F
 where
-    F: Fn(T, &[KeyValue]) + Send + Sync + 'static,
+    F: Fn(T, &[KeyValue<'_>]) + Send + Sync + 'static,
 {
-    fn call(&self, measurement: T, attrs: &[KeyValue]) {
+    fn call(&self, measurement: T, attrs: &[KeyValue<'_>]) {
         self(measurement, attrs)
     }
 }
@@ -69,7 +69,7 @@ pub(crate) struct AggregateBuilder<T> {
     _marker: marker::PhantomData<T>,
 }
 
-type Filter = Arc<dyn Fn(&KeyValue) -> bool + Send + Sync>;
+type Filter = Arc<dyn Fn(&KeyValue<'_>) -> bool + Send + Sync>;
 
 impl<T: Number<T>> AggregateBuilder<T> {
     pub(crate) fn new(temporality: Option<Temporality>, filter: Option<Filter>) -> Self {
@@ -83,9 +83,9 @@ impl<T: Number<T>> AggregateBuilder<T> {
     /// Wraps the passed in measure with an attribute filtering function.
     fn filter(&self, f: impl Measure<T>) -> impl Measure<T> {
         let filter = self.filter.clone();
-        move |n, attrs: &[KeyValue]| {
+        move |n, attrs: &[KeyValue<'_>]| {
             if let Some(filter) = &filter {
-                let filtered_attrs: Vec<KeyValue> =
+                let filtered_attrs: Vec<KeyValue<'_>> =
                     attrs.iter().filter(|kv| filter(kv)).cloned().collect();
                 f.call(n, &filtered_attrs);
             } else {
@@ -101,7 +101,7 @@ impl<T: Number<T>> AggregateBuilder<T> {
         let t = self.temporality;
 
         (
-            self.filter(move |n, a: &[KeyValue]| lv_filter.measure(n, a)),
+            self.filter(move |n, a: &[KeyValue<'_>]| lv_filter.measure(n, a)),
             move |dest: Option<&mut dyn Aggregation>| {
                 let g = dest.and_then(|d| d.as_mut().downcast_mut::<Gauge<T>>());
                 let mut new_agg = if g.is_none() {
@@ -135,7 +135,7 @@ impl<T: Number<T>> AggregateBuilder<T> {
         let t = self.temporality;
 
         (
-            self.filter(move |n, a: &[KeyValue]| s.measure(n, a)),
+            self.filter(move |n, a: &[KeyValue<'_>]| s.measure(n, a)),
             move |dest: Option<&mut dyn Aggregation>| match t {
                 Some(Temporality::Delta) => agg_sum.delta(dest),
                 _ => agg_sum.cumulative(dest),
@@ -150,7 +150,7 @@ impl<T: Number<T>> AggregateBuilder<T> {
         let t = self.temporality;
 
         (
-            self.filter(move |n, a: &[KeyValue]| s.measure(n, a)),
+            self.filter(move |n, a: &[KeyValue<'_>]| s.measure(n, a)),
             move |dest: Option<&mut dyn Aggregation>| match t {
                 Some(Temporality::Delta) => agg_sum.delta(dest),
                 _ => agg_sum.cumulative(dest),
@@ -170,7 +170,7 @@ impl<T: Number<T>> AggregateBuilder<T> {
         let t = self.temporality;
 
         (
-            self.filter(move |n, a: &[KeyValue]| h.measure(n, a)),
+            self.filter(move |n, a: &[KeyValue<'_>]| h.measure(n, a)),
             move |dest: Option<&mut dyn Aggregation>| match t {
                 Some(Temporality::Delta) => agg_h.delta(dest),
                 _ => agg_h.cumulative(dest),
@@ -196,7 +196,7 @@ impl<T: Number<T>> AggregateBuilder<T> {
         let t = self.temporality;
 
         (
-            self.filter(move |n, a: &[KeyValue]| h.measure(n, a)),
+            self.filter(move |n, a: &[KeyValue<'_>]| h.measure(n, a)),
             move |dest: Option<&mut dyn Aggregation>| match t {
                 Some(Temporality::Delta) => agg_h.delta(dest),
                 _ => agg_h.cumulative(dest),

opentelemetry-sdk/src/metrics/internal/exponential_histogram.rs

@@ -340,7 +340,7 @@ impl<T: Number<T>> ExpoHistogram<T> {
         }
     }
 
-    pub(crate) fn measure(&self, value: T, attrs: &[KeyValue]) {
+    pub(crate) fn measure(&self, value: T, attrs: &[KeyValue<'_>]) {
         let f_value = value.into_float();
         // Ignore NaN and infinity.
         if f_value.is_infinite() || f_value.is_nan() {

opentelemetry-sdk/src/metrics/internal/histogram.rs

@@ -120,7 +120,7 @@ impl<T: Number<T>> Histogram<T> {
         histogram
     }
 
-    pub(crate) fn measure(&self, measurement: T, attrs: &[KeyValue]) {
+    pub(crate) fn measure(&self, measurement: T, attrs: &[KeyValue<'_>]) {
         let f = measurement.into_float();
 
         // This search will return an index in the range `[0, bounds.len()]`, where

opentelemetry-sdk/src/metrics/internal/last_value.rs

@@ -23,7 +23,7 @@ impl<T: Number<T>> LastValue<T> {
         }
     }
 
-    pub(crate) fn measure(&self, measurement: T, attrs: &[KeyValue]) {
+    pub(crate) fn measure(&self, measurement: T, attrs: &[KeyValue<'_>]) {
         // The argument index is not applicable to LastValue.
         self.value_map.measure(measurement, attrs, 0);
     }