feat(minidump): Parse Chromium stability report from minidumps (#4837)

- Ref getsentry/sentry#89156

This PR:
- Updates the `minidump` crate to the latest version which supports
parsing the stability report stream
- Adds a `StabilityReportContext` context type with conversions from the
minidump types
- If there is a `crashpad` annotations stream, we also check for the
stability report stream
- If a stability report stream is found, it's added to the context as
`chromium_stability_report`.
- Some memory values in the report are in 4K blocks so these are
multiplied by 4096 so that all values are in bytes

Author: timfish

CHANGELOG.md

@@ -3,9 +3,9 @@
 ## Unreleased
 
 **Features**:
-
 - Add configuration to allow high cardinality tags in metrics. ([#4805](https://github.com/getsentry/relay/pull/4805))
 - Make client sdk mandatory for profile sample v2. ([#4853](https://github.com/getsentry/relay/pull/4853))
+- Parse Chromium stability report from minidumps into context ([#4837](https://github.com/getsentry/relay/pull/4837))
 
 **Internal**:
 
@@ -24,7 +24,7 @@
 **Features**:
 
 - Implements a minimum sample rate dynamic sampling rule. ([#4801](https://github.com/getsentry/relay/pull/4801))
-- Convert NEL reports into logs. ([#4813](https://github.com/getsentry/relay/pull/4813)
+- Convert NEL reports into logs. ([#4813](https://github.com/getsentry/relay/pull/4813))
 - Add parsing for _Nintendo Switch_ to populate `os.name="Nintendo OS"`. ([#4821](https://github.com/getsentry/relay/pull/4821))
 
 **Internal**:

Cargo.lock

@@ -136,7 +136,7 @@ maxminddb = "0.24.0"
 md5 = "0.7.0"
 memchr = "2.7.4"
 mime = "0.3.17"
-minidump = "0.22.2"
+minidump = "0.26.0"
 multer = "3.1.0"
 num-traits = "0.2.19"
 num_cpus = "1.13.1"

Cargo.toml

@@ -18,6 +18,7 @@ chrono = { workspace = true, features = ["clock"] }
 cookie = { workspace = true, features = ["percent-encode"] }
 debugid = { workspace = true, features = ["serde"] }
 enumset = { workspace = true }
+minidump = { workspace = true }
 opentelemetry-proto = { workspace = true, features = ["gen-tonic", "trace"] }
 relay-common = { workspace = true }
 relay-base-schema = { workspace = true }

relay-event-schema/Cargo.toml

@@ -0,0 +1,238 @@
+use relay_protocol::{Annotated, Array, Empty, FromValue, IntoValue};
+
+use crate::processor::ProcessValue;
+
+/// Some stability report fields are measured in 4K pages which we convert to bytes.
+fn bytes_from_4k_pages(value: u32) -> u64 {
+    (value as u64) * 4096
+}
+
+/// The state of a process.
+#[derive(Clone, Debug, Default, PartialEq, Empty, FromValue, IntoValue, ProcessValue)]
+pub struct ProcessStateContext {
+    /// The identifier of the process.
+    pub process_id: Annotated<u64>,
+    /// Process memory state
+    pub memory_state: Annotated<process_state::MemoryStateContext>,
+    /// Process file system state
+    pub file_system_state: Annotated<process_state::FileSystemStateContext>,
+}
+
+/// Nested message and enum types in `ProcessState`.
+pub mod process_state {
+    use super::*;
+
+    /// Records the state of process memory at the time of crash.
+    /// Next id: 6
+    #[derive(Clone, Debug, Default, PartialEq, Empty, FromValue, IntoValue, ProcessValue)]
+    pub struct MemoryStateContext {
+        pub windows_memory: Annotated<memory_state::WindowsMemoryContext>,
+    }
+    /// Nested message and enum types in `MemoryState`.
+    pub mod memory_state {
+        use super::*;
+
+        #[derive(Clone, Debug, Default, PartialEq, Empty, FromValue, IntoValue, ProcessValue)]
+        pub struct WindowsMemoryContext {
+            /// The private byte usage of the process.
+            pub process_private_usage: Annotated<u64>,
+            /// The peak working set usage of the process.
+            pub process_peak_workingset_size: Annotated<u64>,
+            /// The peak pagefile usage of the process.
+            pub process_peak_pagefile_usage: Annotated<u64>,
+            /// The allocation request that caused OOM bytes.
+            pub process_allocation_attempt: Annotated<u64>,
+        }
+    }
+    /// Records the state of the file system at the time of crash.
+    #[derive(Clone, Debug, Default, PartialEq, Empty, FromValue, IntoValue, ProcessValue)]
+    pub struct FileSystemStateContext {
+        /// The state of the file system for POSIX systems.
+        pub posix_file_system_state: Annotated<file_system_state::PosixFileSystemStateContext>,
+        /// The state of the file system for Windows systems.
+        pub windows_file_system_state: Annotated<file_system_state::WindowsFileSystemStateContext>,
+    }
+    /// Nested message and enum types in `FileSystemState`.
+    pub mod file_system_state {
+        use super::*;
+
+        #[derive(Clone, Debug, Default, PartialEq, Empty, FromValue, IntoValue, ProcessValue)]
+        pub struct PosixFileSystemStateContext {
+            /// The number of open file descriptors in the crashing process.
+            pub open_file_descriptors: Annotated<u64>,
+        }
+        #[derive(Clone, Debug, Default, PartialEq, Empty, FromValue, IntoValue, ProcessValue)]
+        pub struct WindowsFileSystemStateContext {
+            /// The number of open handles in the process.
+            pub process_handle_count: Annotated<u64>,
+        }
+    }
+}
+/// Records the state of system memory at the time of crash.
+#[derive(Clone, Debug, Default, PartialEq, Empty, FromValue, IntoValue, ProcessValue)]
+pub struct SystemMemoryStateContext {
+    pub windows_memory: Annotated<system_memory_state::WindowsMemoryContext>,
+}
+/// Nested message and enum types in `SystemMemoryState`.
+pub mod system_memory_state {
+    use super::*;
+
+    #[derive(Clone, Debug, Default, PartialEq, Empty, FromValue, IntoValue, ProcessValue)]
+
+    pub struct WindowsMemoryContext {
+        /// The system commit limit.
+        pub system_commit_limit: Annotated<u64>,
+        /// The amount of system commit remaining.
+        pub system_commit_remaining: Annotated<u64>,
+        /// The current number of open handles.
+        pub system_handle_count: Annotated<u64>,
+    }
+}
+
+/// A stability report contains information pertaining to the execution of a
+/// single logical instance of a "chrome browser". It is comprised of information
+/// about the system state and about the chrome browser's processes.
+
+#[derive(Clone, Debug, Default, PartialEq, Empty, FromValue, IntoValue, ProcessValue)]
+pub struct StabilityReportContext {
+    /// State pertaining to Chrome's processes.
+    pub process_states: Annotated<Array<ProcessStateContext>>,
+    /// System-wide resource usage.
+    pub system_memory_state: Annotated<SystemMemoryStateContext>,
+}
+
+impl super::DefaultContext for StabilityReportContext {
+    fn default_key() -> &'static str {
+        "chromium_stability_report"
+    }
+
+    fn from_context(context: super::Context) -> Option<Self> {
+        match context {
+            super::Context::ChromiumStabilityReport(c) => Some(*c),
+            _ => None,
+        }
+    }
+
+    fn cast(context: &super::Context) -> Option<&Self> {
+        match context {
+            super::Context::ChromiumStabilityReport(c) => Some(c),
+            _ => None,
+        }
+    }
+
+    fn cast_mut(context: &mut super::Context) -> Option<&mut Self> {
+        match context {
+            super::Context::ChromiumStabilityReport(c) => Some(c),
+            _ => None,
+        }
+    }
+
+    fn into_context(self) -> super::Context {
+        super::Context::ChromiumStabilityReport(Box::new(self))
+    }
+}
+
+// From implementations for converting from minidump types
+impl From<minidump::StabilityReport> for StabilityReportContext {
+    fn from(report: minidump::StabilityReport) -> Self {
+        Self {
+            process_states: Annotated::from(
+                report
+                    .process_states
+                    .into_iter()
+                    .map(|ps| Annotated::from(ProcessStateContext::from(ps)))
+                    .collect::<Vec<_>>(),
+            ),
+            system_memory_state: report.system_memory_state.map(Into::into).into(),
+        }
+    }
+}
+
+impl From<minidump::ProcessState> for ProcessStateContext {
+    fn from(state: minidump::ProcessState) -> Self {
+        Self {
+            process_id: state.process_id.map(|id| id as u64).into(),
+            memory_state: state.memory_state.map(Into::into).into(),
+            file_system_state: state.file_system_state.map(Into::into).into(),
+        }
+    }
+}
+
+impl From<minidump::SystemMemoryState> for SystemMemoryStateContext {
+    fn from(state: minidump::SystemMemoryState) -> Self {
+        Self {
+            windows_memory: state.windows_memory.map(Into::into).into(),
+        }
+    }
+}
+
+impl From<minidump::system_memory_state::WindowsMemory>
+    for system_memory_state::WindowsMemoryContext
+{
+    fn from(memory: minidump::system_memory_state::WindowsMemory) -> Self {
+        Self {
+            system_commit_limit: memory.system_commit_limit.map(bytes_from_4k_pages).into(),
+            system_commit_remaining: memory
+                .system_commit_remaining
+                .map(bytes_from_4k_pages)
+                .into(),
+            system_handle_count: memory.system_handle_count.map(|v| v as u64).into(),
+        }
+    }
+}
+
+impl From<minidump::process_state::MemoryState> for process_state::MemoryStateContext {
+    fn from(state: minidump::process_state::MemoryState) -> Self {
+        Self {
+            windows_memory: state.windows_memory.map(Into::into).into(),
+        }
+    }
+}
+
+impl From<minidump::process_state::memory_state::WindowsMemory>
+    for process_state::memory_state::WindowsMemoryContext
+{
+    fn from(memory: minidump::process_state::memory_state::WindowsMemory) -> Self {
+        Self {
+            process_private_usage: memory.process_private_usage.map(bytes_from_4k_pages).into(),
+            process_peak_workingset_size: memory
+                .process_peak_workingset_size
+                .map(bytes_from_4k_pages)
+                .into(),
+            process_peak_pagefile_usage: memory
+                .process_peak_pagefile_usage
+                .map(bytes_from_4k_pages)
+                .into(),
+            process_allocation_attempt: memory.process_allocation_attempt.map(|v| v as u64).into(),
+        }
+    }
+}
+
+impl From<minidump::process_state::FileSystemState> for process_state::FileSystemStateContext {
+    fn from(state: minidump::process_state::FileSystemState) -> Self {
+        Self {
+            posix_file_system_state: state.posix_file_system_state.map(Into::into).into(),
+            windows_file_system_state: state.windows_file_system_state.map(Into::into).into(),
+        }
+    }
+}
+
+impl From<minidump::process_state::file_system_state::PosixFileSystemState>
+    for process_state::file_system_state::PosixFileSystemStateContext
+{
+    fn from(state: minidump::process_state::file_system_state::PosixFileSystemState) -> Self {
+        Self {
+            open_file_descriptors: state.open_file_descriptors.map(|v| v as u64).into(),
+        }
+    }
+}
+
+impl From<minidump::process_state::file_system_state::WindowsFileSystemState>
+    for process_state::file_system_state::WindowsFileSystemStateContext
+{
+    fn from(state: minidump::process_state::file_system_state::WindowsFileSystemState) -> Self {
+        Self {
+            process_handle_count: state.process_handle_count.map(|v| v as u64).into(),
+        }
+    }
+}

relay-event-schema/src/protocol/contexts/chromium_stability_report.rs

@@ -1,5 +1,6 @@
 mod app;
 mod browser;
+mod chromium_stability_report;
 mod cloud_resource;
 mod device;
 mod flags;
@@ -20,6 +21,7 @@ mod trace;
 mod user_report_v2;
 pub use app::*;
 pub use browser::*;
+pub use chromium_stability_report::*;
 pub use cloud_resource::*;
 pub use device::*;
 pub use gpu::*;
@@ -98,6 +100,8 @@ pub enum Context {
     Spring(Box<SpringContext>),
     /// OTA Updates information.
     OTAUpdates(Box<OTAUpdatesContext>),
+    /// Chromium Stability Report from minidump.
+    ChromiumStabilityReport(Box<StabilityReportContext>),
     /// Additional arbitrary fields for forwards compatibility.
     #[metastructure(fallback_variant)]
     Other(#[metastructure(pii = "true")] Object<Value>),