Struct relay_event_schema::protocol::Thread

pub struct Thread {
    pub id: Annotated<ThreadId>,
    pub name: Annotated<String>,
    pub stacktrace: Annotated<Stacktrace>,
    pub raw_stacktrace: Annotated<RawStacktrace>,
    pub crashed: Annotated<bool>,
    pub current: Annotated<bool>,
    pub main: Annotated<bool>,
    pub state: Annotated<String>,
    pub held_locks: Annotated<Object<LockReason>>,
    pub other: Object<Value>,
}

A process thread of an event.

The Threads Interface specifies threads that were running at the time an event happened. These threads can also contain stack traces.

An event may contain one or more threads in an attribute named threads.

The following example illustrates the threads part of the event payload and omits other attributes for simplicity.

{
  "threads": {
    "values": [
      {
        "id": "0",
        "name": "main",
        "crashed": true,
        "stacktrace": {}
      }
    ]
  }
}

Fields

id: Annotated<ThreadId>

The ID of the thread. Typically a number or numeric string.

Needs to be unique among the threads. An exception can set the thread_id attribute to cross-reference this thread.

name: Annotated<String>

Display name of this thread.

stacktrace: Annotated<Stacktrace>

Stack trace containing frames of this exception.

The thread that crashed with an exception should not have a stack trace, but instead, the thread_id attribute should be set on the exception and Sentry will connect the two.

raw_stacktrace: Annotated<RawStacktrace>

Optional unprocessed stack trace.

crashed: Annotated<bool>

A flag indicating whether the thread crashed. Defaults to false.

current: Annotated<bool>

A flag indicating whether the thread was in the foreground. Defaults to false.

main: Annotated<bool>

A flag indicating whether the thread was responsible for rendering the user interface.

state: Annotated<String>

Thread state at the time of the crash.

held_locks: Annotated<Object<LockReason>>

Represents a collection of locks (java monitor objects) held by a thread.

A map of lock object addresses and their respective lock reason/details.

other: Object<Value>

Additional arbitrary fields for forwards compatibility.

Trait Implementations

impl Clone for Thread

fn clone(&self) -> Thread

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Thread

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

Formats the value using the given formatter.

impl Default for Thread

fn default() -> Thread

Returns the “default value” for a type.

impl Empty for Thread

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 Thread

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

Creates a meta structure from an annotated boxed value.

impl IntoValue for Thread

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 Thread

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

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 Thread