sentry 0.46.2

Sentry (sentry.io) client for Rust.
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

use std::thread;
use std::time::Duration;

use sentry::protocol::Request;

// cargo run --example performance-demo
fn main() {
    let _sentry = sentry::init(sentry::ClientOptions {
        release: sentry::release_name!(),
        traces_sample_rate: 1.0,
        debug: true,
        ..Default::default()
    });

    let transaction =
        sentry::start_transaction(sentry::TransactionContext::new("transaction", "root span"));
    let tx_request = Request {
        url: Some("https://honk.beep".parse().unwrap()),
        method: Some("GET".to_string()),
        ..Request::default()
    };
    transaction.set_request(tx_request);
    sentry::configure_scope(|scope| scope.set_span(Some(transaction.clone().into())));

    main_span1();

    thread::sleep(Duration::from_millis(100));

    transaction.finish();
    sentry::configure_scope(|scope| scope.set_span(None));
}

fn main_span1() {
    wrap_in_span("span1", "", || {
        thread::sleep(Duration::from_millis(50));

        let transaction_ctx = sentry::TransactionContext::continue_from_span(
            "background transaction",
            "root span",
            sentry::configure_scope(|scope| scope.get_span()),
        );
        thread::spawn(move || {
            let transaction = sentry::start_transaction(transaction_ctx);
            sentry::configure_scope(|scope| scope.set_span(Some(transaction.clone().into())));

            thread::sleep(Duration::from_millis(50));

            thread_span1();

            transaction.finish();
            sentry::configure_scope(|scope| scope.set_span(None));
        });
        thread::sleep(Duration::from_millis(100));

        main_span2()
    });
}

fn thread_span1() {
    wrap_in_span("span1", "", || {
        thread::sleep(Duration::from_millis(200));
    })
}

fn main_span2() {
    wrap_in_span("span2", "", || {
        sentry::capture_message(
            "A message that should have a trace context",
            sentry::Level::Info,
        );
        thread::sleep(Duration::from_millis(200));
    })
}

fn wrap_in_span<F, R>(op: &str, description: &str, f: F) -> R
where
    F: FnOnce() -> R,
{
    let parent = sentry::configure_scope(|scope| scope.get_span());
    let span1: sentry::TransactionOrSpan = match &parent {
        Some(parent) => parent.start_child(op, description).into(),
        None => {
            let ctx = sentry::TransactionContext::new(description, op);
            sentry::start_transaction(ctx).into()
        }
    };
    let span_request = Request {
        url: Some("https://beep.beep".parse().unwrap()),
        method: Some("GET".to_string()),
        ..Request::default()
    };
    span1.set_request(span_request);
    sentry::configure_scope(|scope| scope.set_span(Some(span1.clone())));

    let rv = f();

    span1.finish();
    sentry::configure_scope(|scope| scope.set_span(parent));

    rv
}