tracing-tracy 0.7.0

Inspect tracing-enabled Rust applications with Tracy
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
115
116
117
118
119

use futures::future::join_all;
use tracing::{debug, event, info, info_span, span, Level};
use tracing_attributes::instrument;
use tracing_subscriber::layer::SubscriberExt;

fn it_works() {
    let span = span!(Level::TRACE, "a sec");
    let _enter = span.enter();
    event!(Level::INFO, "EXPLOSION!");
}

fn it_works_2() {
    let span = span!(Level::TRACE, "2 secs");
    let _enter = span.enter();
    event!(
        Level::INFO,
        message = "DOUBLE THE EXPLOSION!",
        tracy.frame_mark = true
    );
}

fn multiple_entries() {
    let span = span!(Level::INFO, "multiple_entries");
    span.in_scope(|| {});
    span.in_scope(|| {});

    let span = span!(Level::INFO, "multiple_entries 2");
    span.in_scope(|| span.in_scope(|| {}));
}

fn out_of_order() {
    let span1 = span!(Level::INFO, "out of order exits 1");
    let span2 = span!(Level::INFO, "out of order exits 2");
    let span3 = span!(Level::INFO, "out of order exits 3");
    let entry1 = span1.enter();
    let entry2 = span2.enter();
    let entry3 = span3.enter();
    drop(entry2);
    drop(entry3);
    drop(entry1);
}

fn exit_in_different_thread() {
    let span = Box::leak(Box::new(span!(Level::INFO, "exit in different thread")));
    let entry = span.enter();
    let thread = std::thread::spawn(move || drop(entry));
    thread.join().unwrap();
}

async fn parent_task(subtasks: usize) {
    info!("spawning subtasks...");
    let subtasks = (1..=subtasks)
        .map(|number| {
            debug!(message = "creating subtask;", number);
            subtask(number)
        })
        .collect::<Vec<_>>();

    let result = join_all(subtasks).await;

    debug!("all subtasks completed");
    let sum: usize = result.into_iter().sum();
    info!(sum);
}

#[instrument]
async fn subtask(number: usize) -> usize {
    info!("sleeping in subtask {}...", number);
    tokio::time::delay_for(std::time::Duration::from_millis(10)).await;
    info!("sleeping in subtask {}...", number);
    tokio::time::delay_for(std::time::Duration::from_millis(number as _)).await;
    info!("sleeping in subtask {}...", number);
    tokio::time::delay_for(std::time::Duration::from_millis(10)).await;
    number
}

// Test based on the spawny_things example from the tracing repository.
async fn async_futures() {
    parent_task(5).await;
}

fn message_too_long() {
    info!("{}", "a".repeat(u16::max_value().into()));
}

fn long_span_data() {
    let data = "c".repeat(u16::max_value().into());
    info_span!("some span name", "{}", data).in_scope(|| {});
}

fn span_with_fields() {
    let span = span!(
        Level::TRACE,
        "wait",
        duration = 0,
        reason = "testing fields"
    );
    let _enter = span.enter();
}

pub(crate) fn main() {
    tracing::subscriber::set_global_default(
        tracing_subscriber::registry().with(super::TracyLayer::new()),
    )
    .expect("setup the subscriber");
    it_works();
    it_works_2();
    multiple_entries();
    out_of_order();
    exit_in_different_thread();
    message_too_long();
    long_span_data();
    span_with_fields();
    let mut runtime = tokio::runtime::Builder::new()
        .enable_all()
        .build()
        .expect("tokio runtime");
    runtime.block_on(async_futures());
}