6 releases (breaking)

0.20.0 Jan 31, 2024
0.19.1 Nov 2, 2023
0.18.0 Sep 18, 2023
0.17.0 May 17, 2023
0.16.0 May 17, 2023

#286 in Debugging

Download history 1064/week @ 2023-10-27 455/week @ 2023-11-03 1674/week @ 2023-11-10 982/week @ 2023-11-17 1635/week @ 2023-11-24 631/week @ 2023-12-01 2324/week @ 2023-12-08 2592/week @ 2023-12-15 312/week @ 2023-12-22 417/week @ 2023-12-29 610/week @ 2024-01-05 627/week @ 2024-01-12 1172/week @ 2024-01-19 910/week @ 2024-01-26 968/week @ 2024-02-02 1337/week @ 2024-02-09

4,424 downloads per month
Used in 6 crates (5 directly)

MIT license

1.5MB
25K SLoC

minidump-unwind

crates.io

A library for unwinding and producing stack traces from minidump files. This crate provides APIs for producing symbolicated stack traces for the threads in a minidump. The primary entrypoint is the walk_stack function.

If you want lower-level access to the minidump's contents, use the minidump crate.

If you want higher-level functionality build on top of this crate, see minidump-processor.

Example Usage

use minidump::{
    Minidump, MinidumpException, MinidumpMiscInfo, MinidumpModuleList, MinidumpSystemInfo,
    UnifiedMemoryList
};
use minidump_unwind::{CallStack, http_symbol_supplier, Symbolizer, SystemInfo, walk_stack};

#[tokio::main]
async fn main() {
    // Read the minidump
    let dump = Minidump::read_path("../testdata/test.dmp").unwrap();

    // Configure the symbolizer and processor
    let symbols_urls = vec![String::from("https://symbols.totallyrealwebsite.org")];
    let symbols_paths = vec![];
    let mut symbols_cache = std::env::temp_dir();
    symbols_cache.push("minidump-cache");
    let symbols_tmp = std::env::temp_dir();
    let timeout = std::time::Duration::from_secs(1000);

    // Specify a symbol supplier (here we're using the most powerful one, the http supplier)
    let provider = Symbolizer::new(http_symbol_supplier(
        symbols_paths,
        symbols_urls,
        symbols_cache,
        symbols_tmp,
        timeout,
    ));

    let system_info: MinidumpSystemInfo = dump.get_stream().unwrap();
    let misc_info: Option<MinidumpMiscInfo> = dump.get_stream().ok();
    let modules: MinidumpModuleList = dump.get_stream().unwrap();
    let exception: MinidumpException = dump.get_stream().unwrap();
    let exception_context = exception.context(&system_info, misc_info.as_ref()).unwrap();
    let memory_list = dump.get_stream().map(UnifiedMemoryList::Memory)
        .or_else(|_| dump.get_stream().map(UnifiedMemoryList::Memory64))
        .unwrap();

    let stack_memory = memory_list.memory_at_address(exception_context.get_stack_pointer());

    let mut stack = CallStack::with_context(exception_context.into_owned());

    walk_stack(
        0,
        (),
        &mut stack,
        stack_memory,
        &modules,
        &SystemInfo {
            os: system_info.os,
            os_version: None,
            os_build: None,
            cpu: system_info.cpu,
            cpu_info: system_info.cpu_info().map(|info| info.into_owned()),
            cpu_microcode_version: None,
            cpu_count: 1,
        },
        &provider,
    ).await;

    for frame in stack.frames {
        println!("{:?}", frame);
    }
}

Dependencies

~7–23MB
~386K SLoC