tracing-opentelemetry-setup 0.8.4

Utilities to provide proper setup of tracing with OTEL export
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

use opentelemetry::{SpanId, TraceId, KeyValue};
use opentelemetry::trace::{SpanContext, TraceFlags, SpanKind, Status};
use opentelemetry::Context;
use opentelemetry_sdk::trace::{ShouldSample, SamplingDecision};

use crate::builder::{ParentBasedSampler, AlwaysOnSampler, AlwaysOffSampler};

use std::borrow::Cow;

#[derive(Debug)]
struct TestSpan(SpanContext);

impl opentelemetry::trace::Span for TestSpan {
    fn add_event_with_timestamp<T>(&mut self, _name: T, _timestamp: std::time::SystemTime, _attributes: Vec<KeyValue>) where T: Into<Cow<'static, str>> {
    }

    fn span_context(&self) -> &SpanContext {
        &self.0
    }
    fn is_recording(&self) -> bool {
        false
    }
    fn set_attribute(&mut self, _attribute: KeyValue) {}
    fn set_status(&mut self, _status: Status) {}
    fn update_name<T>(&mut self, _new_name: T) where T: Into<Cow<'static, str>> {
    }

    fn add_link(&mut self, _span_context: SpanContext, _attributes: Vec<KeyValue>) {}
    fn end_with_timestamp(&mut self, _timestamp: std::time::SystemTime) {}
}

#[test]
fn should_use_parent_decision_if_sampled() {
    use opentelemetry::trace::TraceContextExt;

    let sampler = ParentBasedSampler {
        sampler: AlwaysOffSampler,
    };
    let span_context = SpanContext::new(
        TraceId::from(1),
        SpanId::from(1),
        TraceFlags::SAMPLED,
        false,
        Default::default(),
    );
    let context = Context::new().with_span(TestSpan(span_context));
    let result = sampler.should_sample(Some(&context), 2.into(), "child_span", &SpanKind::Internal, &[], &[]);
    assert_eq!(result.decision, SamplingDecision::RecordAndSample);
}

#[test]
fn should_use_parent_decision_if_not_sampled() {
    use opentelemetry::trace::TraceContextExt;

    let sampler = ParentBasedSampler {
        sampler: AlwaysOnSampler,
    };
    let span_context = SpanContext::new(
        TraceId::from(1),
        SpanId::from(1),
        TraceFlags::NOT_SAMPLED,
        false,
        Default::default(),
    );
    let context = Context::new().with_span(TestSpan(span_context));
    let result = sampler.should_sample(Some(&context), 2.into(), "child_span", &SpanKind::Internal, &[], &[]);
    assert_eq!(result.decision, SamplingDecision::Drop);
}

#[test]
fn should_use_own_decision_if_no_parent() {
    let sampler = ParentBasedSampler {
        sampler: AlwaysOffSampler,
    };
    let result = sampler.should_sample(None, 2.into(), "child_span", &SpanKind::Internal, &[], &[]);
    assert_eq!(result.decision, SamplingDecision::Drop);

    let sampler = ParentBasedSampler {
        sampler: AlwaysOnSampler,
    };
    let result = sampler.should_sample(None, 2.into(), "child_span", &SpanKind::Internal, &[], &[]);
    assert_eq!(result.decision, SamplingDecision::RecordAndSample);
}