exceptionless 0.1.0

Rust client for Exceptionless tracking errors, log messages, and feature usage events
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

mod support;

use std::{
    error::Error as StdError,
    fmt::{Display, Formatter},
};

use exceptionless::ExceptionlessClient;
use support::{CapturingTransport, payload_events, test_config};

#[derive(Debug)]
struct SimpleError;

impl Display for SimpleError {
    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
        write!(f, "simple error")
    }
}

impl StdError for SimpleError {}

#[tokio::test]
async fn error_stack_trace_contains_real_call_frames() -> Result<(), Box<dyn StdError>> {
    let transport = CapturingTransport::success();
    let client = ExceptionlessClient::new(test_config(), transport.clone());

    client.error(&SimpleError).send().await?;

    let requests = transport.requests();
    let events = payload_events(&requests[0]);
    let error_payload = &events[0]["data"]["@error"];

    let frames = error_payload["stack_trace"]
        .as_array()
        .expect("stack_trace should be an array");

    assert!(!frames.is_empty(), "stack trace must not be empty");

    for frame in frames {
        let method = frame["method"]
            .as_str()
            .expect("each frame must have a method");
        assert!(!method.is_empty(), "frame method must not be empty");
        assert!(
            method.contains("::"),
            "frame method should be a qualified Rust path, got: {method}"
        );
    }

    // At least one frame must originate from this test module
    assert!(
        frames.iter().any(|f| f["method"]

            .as_str()
            .is_some_and(|m| m.contains("regression_error_stack_trace"))),
        "expected at least one frame from this test module"
    );

    Ok(())
}

#[tokio::test]
async fn inner_error_does_not_receive_its_own_backtrace() -> Result<(), Box<dyn StdError>> {
    let transport = CapturingTransport::success();
    let client = ExceptionlessClient::new(test_config(), transport.clone());

    #[derive(Debug)]
    struct Outer(SimpleError);
    impl Display for Outer {
        fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
            write!(f, "outer")
        }
    }
    impl StdError for Outer {
        fn source(&self) -> Option<&(dyn StdError + 'static)> {
            Some(&self.0)
        }
    }

    client.error(&Outer(SimpleError)).send().await?;

    let requests = transport.requests();
    let events = payload_events(&requests[0]);
    let error_payload = &events[0]["data"]["@error"];

    // Outer gets the backtrace
    assert!(
        !error_payload["stack_trace"]
            .as_array()
            .map(|v| v.is_empty())
            .unwrap_or(true),
        "outer error must have a stack trace"
    );

    // Inner error carries no duplicated backtrace of its own
    assert!(
        error_payload["inner"]["stack_trace"]
            .as_array()
            .map(|v| v.is_empty())
            .unwrap_or(true),
        "inner error must not carry its own stack trace"
    );

    Ok(())
}