uxum 0.9.3

Opinionated backend service framework based on axum
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
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114

//! Global OpenTelemetry setup code.

use std::collections::HashMap;

use opentelemetry::KeyValue;
use opentelemetry_otlp::Protocol;
use opentelemetry_resource_detectors::{OsResourceDetector, ProcessResourceDetector};
use opentelemetry_sdk::{
    resource::{EnvResourceDetector, SdkProvidedResourceDetector, TelemetryResourceDetector},
    Resource,
};
use opentelemetry_semantic_conventions::resource as res;
use serde::{Deserialize, Serialize};

use crate::config::AppConfig;

/// OpenTelemetry configuration common for logging, metrics and tracing.
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
#[non_exhaustive]
pub struct TelemetryConfig {
    /// Static labels to add to gathered metrics.
    #[serde(default, skip_serializing_if = "HashMap::is_empty")]
    labels: HashMap<String, String>,
    /// TODO: parse $VARIABLE in label values.
    #[serde(default)]
    parse_labels: bool,
}

impl TelemetryConfig {
    /// Add one static label to be added to gathered metrics.
    #[must_use]
    pub fn with_label<T, U>(&mut self, key: T, value: U) -> &mut Self
    where
        T: ToString,
        U: ToString,
    {
        self.labels.insert(key.to_string(), value.to_string());
        self
    }

    /// Add multiple static labels to be added to gathered metrics.
    #[must_use]
    pub fn with_labels<'a, T, U, V>(&mut self, kvs: V) -> &mut Self
    where
        T: ToString + 'a,
        U: ToString + 'a,
        V: IntoIterator<Item = (&'a T, &'a U)>,
    {
        self.labels.extend(
            kvs.into_iter()
                .map(|(key, val)| (key.to_string(), val.to_string())),
        );
        self
    }

    pub fn static_resources(&self) -> impl Iterator<Item = KeyValue> + '_ {
        self.labels
            .iter()
            .map(|(key, val)| KeyValue::new(key.clone(), val.clone()))
    }
}

impl AppConfig {
    /// Get OpenTelemetry resource.
    ///
    /// Creates new resource object on first call. On subsequent calls returns previously created
    /// object as a clone.
    #[must_use]
    pub fn otel_resource(&self) -> Resource {
        // TODO: res::SERVICE_NAMESPACE.
        // TODO: res::DEPLOYMENT_ENVIRONMENT.
        let mut static_resources: Vec<_> = self.telemetry.static_resources().collect();
        if let Some(val) = &self.app_name {
            static_resources.push(KeyValue::new(res::SERVICE_NAME, val.clone()));
        }
        if let Some(val) = &self.app_version {
            static_resources.push(KeyValue::new(res::SERVICE_VERSION, val.clone()));
        }
        Resource::builder()
            .with_detectors(&[
                Box::new(OsResourceDetector),
                Box::new(ProcessResourceDetector),
                Box::new(SdkProvidedResourceDetector),
                Box::new(EnvResourceDetector::new()),
                Box::new(TelemetryResourceDetector),
            ])
            .with_attributes(static_resources)
            .build()
    }
}

/// OTLP protocol variant to use for data export.
#[derive(Clone, Copy, Debug, Default, Deserialize, PartialEq, Eq, Serialize)]
#[non_exhaustive]
#[serde(rename_all = "snake_case")]
pub enum OtlpProtocol {
    /// GRPC over HTTP.
    #[default]
    Grpc,
    /// Protobuf over HTTP.
    HttpBinary,
    /// JSON over HTTP.
    HttpJson,
}

impl From<OtlpProtocol> for Protocol {
    fn from(value: OtlpProtocol) -> Self {
        match value {
            OtlpProtocol::Grpc => Self::Grpc,
            OtlpProtocol::HttpBinary => Self::HttpBinary,
            OtlpProtocol::HttpJson => Self::HttpJson,
        }
    }
}