Struct Replay

pub struct Replay {

    pub event_id: Annotated<EventId>,
    pub replay_id: Annotated<EventId>,
    pub replay_type: Annotated<String>,
    pub segment_id: Annotated<u64>,
    pub timestamp: Annotated<Timestamp>,
    pub replay_start_timestamp: Annotated<Timestamp>,
    pub urls: Annotated<Array<String>>,
    pub error_ids: Annotated<Array<Uuid>>,
    pub trace_ids: Annotated<Array<Uuid>>,
    pub contexts: Annotated<Contexts>,
    pub platform: Annotated<String>,
    pub release: Annotated<LenientString>,
    pub dist: Annotated<String>,
    pub environment: Annotated<String>,
    pub tags: Annotated<Tags>,
    pub ty: Annotated<String>,
    pub user: Annotated<User>,
    pub request: Annotated<Request>,
    pub sdk: Annotated<ClientSdkInfo>,
}

Fields

event_id: Annotated<EventId>

Unique identifier of this event.

Hexadecimal string representing a uuid4 value. The length is exactly 32 characters. Dashes are not allowed. Has to be lowercase.

Even though this field is backfilled on the server with a new uuid4, it is strongly recommended to generate that uuid4 clientside. There are some features like user feedback which are easier to implement that way, and debugging in case events get lost in your Sentry installation is also easier.

Example:

{
  "event_id": "fc6d8c0c43fc4630ad850ee518f1b9d0"
}

replay_id: Annotated<EventId>

Replay identifier.

Hexadecimal string representing a uuid4 value. The length is exactly 32 characters. Dashes are not allowed. Has to be lowercase.

Example:

{
  "replay_id": "fc6d8c0c43fc4630ad850ee518f1b9d0"
}

replay_type: Annotated<String>

The type of sampling that captured the replay.

A string enumeration. One of “session” or “error”.

Example:

{
  "replay_type": "session"
}

segment_id: Annotated<u64>

Segment identifier.

A number representing a unique segment identifier in the chain of replay segments. Segment identifiers are temporally ordered but can be received by the Relay service in any order.

Example:

{
  "segment_id": 10
}

timestamp: Annotated<Timestamp>

Timestamp when the event was created.

Indicates when the segment was created in the Sentry SDK. The format is either a string as defined in RFC 3339 or a numeric (integer or float) value representing the number of seconds that have elapsed since the Unix epoch.

Timezone is assumed to be UTC if missing.

Sub-microsecond precision is not preserved with numeric values due to precision limitations with floats (at least in our systems). With that caveat in mind, just send whatever is easiest to produce.

All timestamps in the event protocol are formatted this way.

Example

All of these are the same date:

{ "timestamp": "2011-05-02T17:41:36Z" }
{ "timestamp": "2011-05-02T17:41:36" }
{ "timestamp": "2011-05-02T17:41:36.000" }
{ "timestamp": 1304358096.0 }

replay_start_timestamp: Annotated<Timestamp>

Timestamp when the replay was created. Typically only specified on the initial segment.

urls: Annotated<Array<String>>

A list of URLs visted during the lifetime of the segment.

error_ids: Annotated<Array<Uuid>>

A list of error-ids discovered during the lifetime of the segment.

trace_ids: Annotated<Array<Uuid>>

A list of trace-ids discovered during the lifetime of the segment.

contexts: Annotated<Contexts>

Contexts describing the environment (e.g. device, os or browser).

platform: Annotated<String>

Platform identifier of this event (defaults to “other”).

A string representing the platform the SDK is submitting from. This will be used by the Sentry interface to customize various components in the interface.

release: Annotated<LenientString>

The release version of the application.

Release versions must be unique across all projects in your organization. This value can be the git SHA for the given project, or a product identifier with a semantic version.

dist: Annotated<String>

Program’s distribution identifier.

The distribution of the application.

Distributions are used to disambiguate build or deployment variants of the same release of an application. For example, the dist can be the build number of an XCode build or the version code of an Android build.

environment: Annotated<String>

The environment name, such as production or staging.

{ "environment": "production" }

tags: Annotated<Tags>

Custom tags for this event.

A map or list of tags for this event. Each tag must be less than 200 characters.

ty: Annotated<String>

Static value. Should always be “replay_event”.

user: Annotated<User>

Information about the user who triggered this event.

request: Annotated<Request>

Information about a web request that occurred during the event.

sdk: Annotated<ClientSdkInfo>

Information about the Sentry SDK that generated this event.

Implementations

impl Replay

pub fn context<C: DefaultContext>(&self) -> Option<&C>

Returns a reference to the context if it exists in its default key.

pub fn user_agent(&self) -> Option<&str>

Returns the raw user agent string.

Returns Some if the event’s request interface contains a user-agent header. Returns None otherwise.

Trait Implementations

impl Clone for Replay

fn clone(&self) -> Replay

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Replay

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

Formats the value using the given formatter.

impl Default for Replay

fn default() -> Replay

Returns the “default value” for a type.

impl Empty for Replay

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 Replay

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

Creates a meta structure from an annotated boxed value.

impl Getter for Replay

fn get_value(&self, path: &str) -> Option<Val<'_>>

Returns the serialized value of a field pointed to by a path.

fn get_iter(&self, _path: &str) -> Option<GetterIter<'_>>

Returns an iterator over the array pointed to by a path.

impl IntoValue for Replay

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 Replay

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

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 Replay