telemetry-rust 6.10.0

Open Telemetry fox Axum and Tracing
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98

use crate::{Key, KeyValue, StringValue, Value};

/// A trait for converting fluent builder properties into OpenTelemetry key-value attributes.
pub(crate) trait AsAttribute {
    fn as_attribute(&self, key: impl Into<Key>) -> Option<KeyValue>;
}

impl AsAttribute for Option<String> {
    fn as_attribute(&self, key: impl Into<Key>) -> Option<KeyValue> {
        self.as_ref().map(|value| KeyValue::new(key, value.clone()))
    }
}

impl AsAttribute for Option<&str> {
    fn as_attribute(&self, key: impl Into<Key>) -> Option<KeyValue> {
        self.map(ToOwned::to_owned).as_attribute(key)
    }
}

impl AsAttribute for Option<bool> {
    fn as_attribute(&self, key: impl Into<Key>) -> Option<KeyValue> {
        self.map(|value| KeyValue::new(key, value))
    }
}

impl AsAttribute for Option<i32> {
    fn as_attribute(&self, key: impl Into<Key>) -> Option<KeyValue> {
        self.map(Into::<i64>::into).as_attribute(key)
    }
}

impl AsAttribute for Option<i64> {
    fn as_attribute(&self, key: impl Into<Key>) -> Option<KeyValue> {
        self.map(|value| KeyValue::new(key, value))
    }
}

impl AsAttribute for Option<f64> {
    fn as_attribute(&self, key: impl Into<Key>) -> Option<KeyValue> {
        self.map(|value| KeyValue::new(key, value))
    }
}

impl AsAttribute for Option<usize> {
    fn as_attribute(&self, key: impl Into<Key>) -> Option<KeyValue> {
        self.map(TryInto::<i64>::try_into)
            .and_then(Result::ok)
            .as_attribute(key)
    }
}

impl AsAttribute for usize {
    fn as_attribute(&self, key: impl Into<Key>) -> Option<KeyValue> {
        TryInto::<i64>::try_into(*self).ok().as_attribute(key)
    }
}

impl AsAttribute for Option<Vec<String>> {
    fn as_attribute(&self, key: impl Into<Key>) -> Option<KeyValue> {
        self.as_ref().map(|value| {
            let items = value
                .iter()
                .map(|item| item.clone().into())
                .collect::<Vec<StringValue>>();
            KeyValue::new(key, Value::Array(items.into()))
        })
    }
}

#[cfg(feature = "aws-dynamodb")]
mod dynamodb {
    use super::*;
    use aws_sdk_dynamodb::types::Select;

    impl AsAttribute for Option<Select> {
        fn as_attribute(&self, key: impl Into<Key>) -> Option<KeyValue> {
            self.as_ref().map(|value| {
                let value: StringValue = match value {
                    Select::AllAttributes => "ALL_ATTRIBUTES".into(),
                    Select::AllProjectedAttributes => "ALL_PROJECTED_ATTRIBUTES".into(),
                    Select::Count => "COUNT".into(),
                    Select::SpecificAttributes => "SPECIFIC_ATTRIBUTES".into(),
                    other => other.as_str().to_owned().into(),
                };
                KeyValue::new(key, value)
            })
        }
    }
}

/// Helper macro to create attribute arrays that filter out None values
macro_rules! attributes {
    ($($expr:expr),* $(,)?) => {
        [$($expr,)*].into_iter().flatten()
    };
}

pub(crate) use attributes;