microsandbox 0.7.0

`microsandbox` is the core library for the microsandbox project.
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

//! Operation timing for startup stages and cloud agent connections.
//! Enable with `RUST_LOG=info,microsandbox::profiling=trace`.

#[cfg(feature = "local")]
use std::future::Future;
use std::time::Instant;

//--------------------------------------------------------------------------------------------------
// Constants
//--------------------------------------------------------------------------------------------------

/// Log target for opt-in profiling events.
pub(crate) const TARGET: &str = "microsandbox::profiling";

//--------------------------------------------------------------------------------------------------
// Types
//--------------------------------------------------------------------------------------------------

#[cfg(feature = "local")]
struct StageTiming<'a> {
    sandbox_name: &'a str,
    stage: &'static str,
    started: Instant,
    outcome: &'static str,
}

/// Emits one terminal event when a polled connection attempt finishes or is dropped.
#[cfg(feature = "cloud")]
pub(crate) struct ConnectionTiming<'a> {
    name: &'a str,
    id: Option<String>,
    started: Instant,
    stage: &'static str,
    outcome: &'static str,
}

//--------------------------------------------------------------------------------------------------
// Methods
//--------------------------------------------------------------------------------------------------

#[cfg(feature = "cloud")]
impl<'a> ConnectionTiming<'a> {
    pub(crate) fn new(name: &'a str) -> Self {
        Self {
            name,
            id: None,
            started: Instant::now(),
            stage: "identity",
            outcome: "cancelled",
        }
    }

    pub(crate) fn identity(&mut self, id: &str) {
        self.id = Some(id.to_owned());
    }

    pub(crate) fn stage(&mut self, stage: &'static str) {
        self.stage = stage;
    }

    pub(crate) fn finish(&mut self, outcome: &'static str) {
        self.outcome = outcome;
    }
}

//--------------------------------------------------------------------------------------------------
// Trait Implementations
//--------------------------------------------------------------------------------------------------

#[cfg(feature = "local")]
impl Drop for StageTiming<'_> {
    fn drop(&mut self) {
        tracing::trace!(target: TARGET,
            sandbox_name = self.sandbox_name,
            stage = self.stage,
            elapsed_seconds = self.started.elapsed().as_secs_f64(),
            outcome = self.outcome,
            "sandbox startup stage finished"
        );
    }
}

#[cfg(feature = "cloud")]
impl Drop for ConnectionTiming<'_> {
    fn drop(&mut self) {
        tracing::trace!(target: TARGET,
            sandbox_name = self.name,
            sandbox_id = self.id.as_deref().unwrap_or(""),
            elapsed_seconds = self.started.elapsed().as_secs_f64(),
            stage = self.stage,
            outcome = self.outcome,
            "cloud agent connection finished"
        );
    }
}

//--------------------------------------------------------------------------------------------------
// Functions
//--------------------------------------------------------------------------------------------------

/// Measure a fallible startup stage, including errors and future cancellation.
#[cfg(feature = "local")]
pub(crate) async fn measure<T, E>(
    sandbox_name: &str,
    stage: &'static str,
    future: impl Future<Output = Result<T, E>>,
) -> Result<T, E> {
    let mut timing = StageTiming {
        sandbox_name,
        stage,
        started: Instant::now(),
        outcome: "cancelled",
    };
    let result = future.await;
    timing.outcome = if result.is_ok() { "success" } else { "error" };
    result
}