debugbundle 1.0.0-alpha.1

Safe, bounded runtime error reporting for Rust, Axum and Actix Web
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

#![cfg(all(feature = "local", windows))]
use debugbundle::{
    storage::SecureDirectory, wire::valid_event, Client, Config, Context, ExceptionSnapshot,
};
use serde_json::Value;
use std::{process::Command, time::Duration};

#[test]
fn private_windows_output_is_a_protected_canonical_array_and_keeps_local_only_scope() {
    let temp = tempfile::tempdir().unwrap();
    let root = temp.path().join("events");
    let client = Client::new(Config::local("windows-worker", &root));
    assert!(client.status().reason.is_none());
    client.capture_exception(
        &ExceptionSnapshot::new("WindowsFailure", "password=SYNTHETIC_SECRET"),
        &Context::default(),
    );
    assert!(client.flush(Duration::from_secs(5)).drained);
    let file = std::fs::read_dir(&root)
        .unwrap()
        .next()
        .unwrap()
        .unwrap()
        .path();
    let bytes = std::fs::read(&file).unwrap();
    let events: Vec<Value> = serde_json::from_slice(&bytes).unwrap();
    assert_eq!(events.len(), 1);
    assert!(valid_event(&events[0]));
    assert!(!String::from_utf8_lossy(&bytes).contains("SYNTHETIC_SECRET"));
    assert!(client.shutdown(Duration::from_secs(2)).drained);
}

#[test]
fn windows_owned_handles_reject_hardlinks_and_keep_ancestor_names_stable() {
    let temp = tempfile::tempdir().unwrap();
    let root = temp.path().join("events");
    let directory = SecureDirectory::open(&root).unwrap();
    assert!(std::fs::rename(&root, temp.path().join("moved")).is_err());
    // Reuse an actual native SDK envelope rather than a second schema fixture.
    let client = Client::new(Config::local("windows-worker", &root));
    client.capture_exception(
        &ExceptionSnapshot::new("WindowsFailure", "synthetic"),
        &Context::default(),
    );
    assert!(client.flush(Duration::from_secs(5)).drained);
    let file = std::fs::read_dir(&root)
        .unwrap()
        .next()
        .unwrap()
        .unwrap()
        .path();
    std::fs::hard_link(&file, temp.path().join("alias.json")).unwrap();
    assert!(directory
        .read(file.file_name().unwrap().to_str().unwrap())
        .is_err());
    assert!(client.shutdown(Duration::from_secs(2)).drained);
}

#[test]
fn windows_reparse_ancestors_and_widened_file_acls_fail_closed() {
    let temp = tempfile::tempdir().unwrap();
    let outside = tempfile::tempdir().unwrap();
    let junction = temp.path().join("junction");
    let created = Command::new("cmd")
        .args(["/D", "/C", "mklink", "/J"])
        .arg(&junction)
        .arg(outside.path())
        .output()
        .unwrap();
    assert!(
        created.status.success(),
        "native junction fixture must be available"
    );
    assert!(SecureDirectory::open(&junction.join("events")).is_err());
    assert!(outside.path().read_dir().unwrap().next().is_none());
    let root = temp.path().join("events");
    let client = Client::new(Config::local("windows-worker", &root));
    client.capture_exception(
        &ExceptionSnapshot::new("WindowsFailure", "synthetic"),
        &Context::default(),
    );
    assert!(client.flush(Duration::from_secs(5)).drained);
    let file = std::fs::read_dir(&root)
        .unwrap()
        .next()
        .unwrap()
        .unwrap()
        .path();
    let changed = Command::new("icacls")
        .arg(&file)
        .args(["/grant", "*S-1-1-0:(R)"])
        .output()
        .unwrap();
    assert!(
        changed.status.success(),
        "native ACL fixture must be available"
    );
    let directory = SecureDirectory::open(&root).unwrap();
    assert!(directory
        .read(file.file_name().unwrap().to_str().unwrap())
        .is_err());
    assert!(client.shutdown(Duration::from_secs(2)).drained);
}