Struct relay_event_schema::protocol::RawStacktrace

pub struct RawStacktrace {
    pub frames: Annotated<Array<Frame>>,
    pub registers: Annotated<Object<RegVal>>,
    pub instruction_addr_adjustment: Annotated<InstructionAddrAdjustment>,
    pub lang: Annotated<String>,
    pub snapshot: Annotated<bool>,
    pub other: Object<Value>,
}

A stack trace of a single thread.

A stack trace contains a list of frames, each with various bits (most optional) describing the context of that frame. Frames should be sorted from oldest to newest.

For the given example program written in Python:

def foo():
    my_var = 'foo'
    raise ValueError()

def main():
    foo()

A minimalistic stack trace for the above program in the correct order:

{
  "frames": [
    {"function": "main"},
    {"function": "foo"}
  ]
}

The top frame fully symbolicated with five lines of source context:

{
  "frames": [{
    "in_app": true,
    "function": "myfunction",
    "abs_path": "/real/file/name.py",
    "filename": "file/name.py",
    "lineno": 3,
    "vars": {
      "my_var": "'value'"
    },
    "pre_context": [
      "def foo():",
      "  my_var = 'foo'",
    ],
    "context_line": "  raise ValueError()",
    "post_context": [
      "",
      "def main():"
    ],
  }]
}

A minimal native stack trace with register values. Note that the package event attribute must be “native” for these frames to be symbolicated.

{
  "frames": [
    {"instruction_addr": "0x7fff5bf3456c"},
    {"instruction_addr": "0x7fff5bf346c0"},
  ],
  "registers": {
    "rip": "0x00007ff6eef54be2",
    "rsp": "0x0000003b710cd9e0"
  }
}

Fields

frames: Annotated<Array<Frame>>

Required. A non-empty list of stack frames. The list is ordered from caller to callee, or oldest to youngest. The last frame is the one creating the exception.

registers: Annotated<Object<RegVal>>

Register values of the thread (top frame).

A map of register names and their values. The values should contain the actual register values of the thread, thus mapping to the last frame in the list.

instruction_addr_adjustment: Annotated<InstructionAddrAdjustment>

Optional. A flag that indicates if, and how, instruction_addr values need to be adjusted before they are symbolicated.

lang: Annotated<String>

The language of the stacktrace.

snapshot: Annotated<bool>

Indicates that this stack trace is a snapshot triggered by an external signal.

If this field is false, then the stack trace points to the code that caused this stack trace to be created. This can be the location of a raised exception, as well as an exception or signal handler.

If this field is true, then the stack trace was captured as part of creating an unrelated event. For example, a thread other than the crashing thread, or a stack trace computed as a result of an external kill signal.

other: Object<Value>

Additional arbitrary fields for forwards compatibility.

Trait Implementations

impl Clone for RawStacktrace

fn clone(&self) -> RawStacktrace

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for RawStacktrace

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

Formats the value using the given formatter.

impl Default for RawStacktrace

fn default() -> RawStacktrace

Returns the “default value” for a type.

impl Empty for RawStacktrace

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 From<RawStacktrace> for Stacktrace

fn from(stacktrace: RawStacktrace) -> Stacktrace

Converts to this type from the input type.

impl From<Stacktrace> for RawStacktrace

fn from(stacktrace: Stacktrace) -> RawStacktrace

Converts to this type from the input type.

impl FromValue for RawStacktrace

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

Creates a meta structure from an annotated boxed value.

impl IntoValue for RawStacktrace

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 RawStacktrace

fn eq(&self, other: &RawStacktrace) -> 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 RawStacktrace

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 RawStacktrace