async-log 2.0.0

Async tracing capabilities for the log crate.
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

/// The return type of `async_log_capture_caller`
#[derive(Debug)]
pub(crate) struct Symbol {
    pub(crate) name: Option<String>,
    pub(crate) lineno: Option<u32>,
    pub(crate) filename: Option<std::path::PathBuf>,
}

/// Find the method that called this.
///
/// `depth` is how many frames we should look past finding the method where this was called.
/// This might require a bit of wrangling to find.
#[allow(unused_attributes)]
#[no_mangle]
pub(crate) fn async_log_capture_caller(depth: u8) -> Option<Symbol> {
    let mut count = 0;
    let mut counting = false;
    let self_name = "async_log_capture_caller";
    let mut ret_symbol: Option<Symbol> = None;

    backtrace::trace(|frame| {
        if ret_symbol.is_some() {
            return false;
        }
        backtrace::resolve_frame(frame, |symbol| {
            if let Some(name) = symbol.name() {
                if format!("{}", name) == self_name {
                    counting = true;
                }

                if !counting {
                    return;
                }

                count += 1;
                if count == depth {
                    ret_symbol = Some(Symbol {
                        name: symbol.name().map(|s| format!("{}", s)),
                        lineno: symbol.lineno(),
                        filename: symbol.filename().map(|p| p.to_path_buf()),
                    })
                }
            }
        });
        true
    });
    ret_symbol
}