local_async_utils 0.2.13

Utilities for single-threaded async programming
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
120
121
122
123
124
125
126

//! Utilities for measuring the duration of operations and logging if they exceed a specified threshold.

use std::fmt;
use std::time::Instant;

#[cfg(feature = "tokio")]
use tokio::time::Duration;

#[cfg(not(feature = "tokio"))]
use std::time::Duration;

/// Utility for measuring the duration of an operation. When dropped, it will log the time elapsed since its creation.
pub struct Stopwatch {
    lvl: log::Level,
    threshold: Duration,
    starttime: Instant,
    location: &'static str,
    what: String,
}

impl Stopwatch {
    pub fn new(
        lvl: log::Level,
        threshold: Duration,
        location: &'static str,
        args: fmt::Arguments,
    ) -> Self {
        Self {
            lvl,
            threshold,
            starttime: Instant::now(),
            location,
            what: fmt::format(args),
        }
    }
}

impl Drop for Stopwatch {
    fn drop(&mut self) {
        let duration = self.starttime.elapsed();
        if duration > self.threshold {
            log::log!(target: self.location, self.lvl, "{} finished in {:?}", self.what, duration);
        }
    }
}

impl fmt::Debug for Stopwatch {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.debug_struct("Stopwatch").finish()
    }
}

/// Creates a [`Stopwatch`] that will log a trace message if the elapsed time exceeds the threshold.
/// ```
/// use local_async_utils::prelude::*;
///
/// let sw = trace_stopwatch!(sec!(0), "10 milliseconds of sleep");
/// std::thread::sleep(millisec!(10));
/// drop(sw); // Logs: "10 milliseconds of sleep finished in 10ms"
/// ```
#[macro_export]
macro_rules! trace_stopwatch {
    ($threshold:expr, $($arg:tt)+) => {
        $crate::stopwatch::Stopwatch::new(log::Level::Trace, $threshold, module_path!(), format_args!($($arg)+))
    };
}

/// Creates a [`Stopwatch`] that will log a debug message if the elapsed time exceeds the threshold.
/// ```
/// use local_async_utils::prelude::*;
///
/// let sw = debug_stopwatch!(sec!(0), "10 milliseconds of sleep");
/// std::thread::sleep(millisec!(10));
/// drop(sw); // Logs: "10 milliseconds of sleep finished in 10ms"
/// ```
#[macro_export]
macro_rules! debug_stopwatch {
    ($threshold:expr, $($arg:tt)+) => {
        $crate::stopwatch::Stopwatch::new(log::Level::Debug, $threshold, module_path!(), format_args!($($arg)+))
    };
}

/// Creates a [`Stopwatch`] that will log an info message if the elapsed time exceeds the threshold.
/// ```
/// use local_async_utils::prelude::*;
///
/// let sw = info_stopwatch!(sec!(0), "10 milliseconds of sleep");
/// std::thread::sleep(millisec!(10));
/// drop(sw); // Logs: "10 milliseconds of sleep finished in 10ms"
/// ```
#[macro_export]
macro_rules! info_stopwatch {
    ($threshold:expr, $($arg:tt)+) => {
        $crate::stopwatch::Stopwatch::new(log::Level::Info, $threshold, module_path!(), format_args!($($arg)+))
    };
}

/// Creates a [`Stopwatch`] that will log a warning message if the elapsed time exceeds the threshold.
/// ```
/// use local_async_utils::prelude::*;
///
/// let sw = warn_stopwatch!(sec!(0), "10 milliseconds of sleep");
/// std::thread::sleep(millisec!(10));
/// drop(sw); // Logs: "10 milliseconds of sleep finished in 10ms"
/// ```
#[macro_export]
macro_rules! warn_stopwatch {
    ($threshold:expr, $($arg:tt)+) => {
        $crate::stopwatch::Stopwatch::new(log::Level::Warn, $threshold, module_path!(), format_args!($($arg)+))
    };
}

/// Creates a [`Stopwatch`] that will log an error message if the elapsed time exceeds the threshold.
/// ```
/// use local_async_utils::prelude::*;
///
/// let sw = error_stopwatch!(sec!(0), "10 milliseconds of sleep");
/// std::thread::sleep(millisec!(10));
/// drop(sw); // Logs: "10 milliseconds of sleep finished in 10ms"
/// ```
#[macro_export]
macro_rules! error_stopwatch {
    ($threshold:expr, $($arg:tt)+) => {
        $crate::stopwatch::Stopwatch::new(log::Level::Error, $threshold, module_path!(), format_args!($($arg)+))
    };
}