Struct Mechanism

pub struct Mechanism {
    pub ty: Annotated<String>,
    pub synthetic: Annotated<bool>,
    pub description: Annotated<String>,
    pub help_link: Annotated<String>,
    pub handled: Annotated<bool>,
    pub source: Annotated<String>,
    pub is_exception_group: Annotated<bool>,
    pub exception_id: Annotated<u64>,
    pub parent_id: Annotated<u64>,
    pub data: Annotated<Object<Value>>,
    pub meta: Annotated<MechanismMeta>,
    pub other: Object<Value>,
}

The mechanism by which an exception was generated and handled.

The exception mechanism is an optional field residing in the exception. It carries additional information about the way the exception was created on the target system. This includes general exception values obtained from the operating system or runtime APIs, as well as mechanism-specific values.

Fields

ty: Annotated<String>

Mechanism type (required).

Required unique identifier of this mechanism determining rendering and processing of the mechanism data.

In the Python SDK this is merely the name of the framework integration that produced the exception, while for native it is e.g. "minidump" or "applecrashreport".

synthetic: Annotated<bool>

If this is set then the exception is not a real exception but some form of synthetic error for instance from a signal handler, a hard segfault or similar where type and value are not useful for grouping or display purposes.

description: Annotated<String>

Optional human-readable description of the error mechanism.

May include a possible hint on how to solve this error.

help_link: Annotated<String>

Link to online resources describing this error.

handled: Annotated<bool>

Flag indicating whether this exception was handled.

This is a best-effort guess at whether the exception was handled by user code or not. For example:

• Exceptions leading to a 500 Internal Server Error or to a hard process crash are handled=false, as the SDK typically has an integration that automatically captures the error.

• Exceptions captured using capture_exception (called from user code) are handled=true as the user explicitly captured the exception (and therefore kind of handled it)

source: Annotated<String>

An optional string value describing the source of the exception.

For chained exceptions, this should contain the platform-specific name of the property or attribute (on the parent exception) that this exception was acquired from. In the case of an array, it should include the zero-based array index as well.

• Python Examples: "__context__", "__cause__", "exceptions[0]", "exceptions[1]"

• .NET Examples: "InnerException", "InnerExceptions[0]", "InnerExceptions[1]"

• JavaScript Examples: "cause", "errors[0]", "errors[1]"

is_exception_group: Annotated<bool>

An optional boolean value, set true when the exception is the platform-specific exception group type. Defaults to false.

For example, exceptions of type ExceptionGroup (Python), AggregateException (.NET), and AggregateError (JavaScript) should have "is_exception_group": true. Other exceptions can omit this field.

exception_id: Annotated<u64>

An optional numeric value providing an ID for the exception relative to this specific event. It is referenced by the parent_id to reconstruct the logical tree of exceptions in an exception group.

This should contain an unsigned integer value starting with 0 for the last exception in the exception values list, then 1 for the previous exception, etc.

parent_id: Annotated<u64>

An optional numeric value pointing at the exception_id that is the direct parent of this exception, used to reconstruct the logical tree of exceptions in an exception group.

The last exception in the exception values list should omit this field, because it is the root exception and thus has no parent.

data: Annotated<Object<Value>>

Arbitrary extra data that might help the user understand the error thrown by this mechanism.

meta: Annotated<MechanismMeta>

Operating system or runtime meta information.

other: Object<Value>

Additional arbitrary fields for forwards compatibility.

Trait Implementations

impl Clone for Mechanism

fn clone(&self) -> Mechanism

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Mechanism

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for Mechanism

fn default() -> Mechanism

Returns the “default value” for a type.

impl Empty for Mechanism

fn is_empty(&self) -> bool

Returns whether this value is empty.

fn is_deep_empty(&self) -> bool

Returns whether this value is empty or all of its descendants are empty.

impl FromValue for Mechanism

fn from_value(annotated: Annotated<Value>) -> Annotated<Self>

Creates a meta structure from an annotated boxed value.

impl IntoValue for Mechanism

fn into_value(self) -> Value

Boxes the meta structure back into a value.

fn serialize_payload<S>( &self, __serializer: S, __behavior: SkipSerialization, ) -> Result<S::Ok, S::Error>

where Self: Sized, S: Serializer,

Efficiently serializes the payload directly.

fn extract_child_meta(&self) -> MetaMap

where Self: Sized,

Extracts children meta map out of a value.

fn extract_meta_tree(value: &Annotated<Self>) -> MetaTree

where Self: Sized,

Extracts the meta tree out of annotated value.

impl PartialEq for Mechanism

fn eq(&self, other: &Mechanism) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl ProcessValue for Mechanism

fn value_type(&self) -> EnumSet<ValueType>

Returns the type of the value.

fn process_value<P>( &mut self, __meta: &mut Meta, __processor: &mut P, __state: &ProcessingState<'_>, ) -> ProcessingResult

where P: Processor,

Executes a processor on this value.

fn process_child_values<P>( &mut self, __processor: &mut P, __state: &ProcessingState<'_>, ) -> ProcessingResult

where P: Processor,

Recurses into children of this value.

impl StructuralPartialEq for Mechanism