Struct relay_event_schema::protocol::Metrics

pub struct Metrics {

    pub bytes_ingested_event: Annotated<u64>,
    pub bytes_ingested_event_minidump: Annotated<u64>,
    pub bytes_ingested_event_applecrashreport: Annotated<u64>,
    pub bytes_ingested_event_attachment: Annotated<u64>,
    pub bytes_stored_event: Annotated<u64>,
    pub bytes_stored_event_minidump: Annotated<u64>,
    pub bytes_stored_event_applecrashreport: Annotated<u64>,
    pub bytes_stored_event_attachment: Annotated<u64>,
    pub ms_processing_symbolicator: Annotated<u64>,
    pub ms_processing_proguard: Annotated<u64>,
    pub ms_processing_jvm: Annotated<u64>,
    pub ms_processing_sourcemaps: Annotated<u64>,
    pub flag_processing_error: Annotated<bool>,
    pub flag_processing_fatal: Annotated<bool>,
}

Metrics captured during event ingestion and processing.

These values are collected in Relay and Sentry and finally persisted into the event payload. A value of 0 is equivalent to N/A and should not be considered in aggregations and analysis.

Fields

bytes_ingested_event: Annotated<u64>

The size of the original event payload ingested into Sentry.

The size is measured after applying all content- and transfer-encodings and thus independent of compression over the wire.

For security reports, this is the size of the JSON request sent by the browser and not of the event payload we extract from it. For ingested envelopes, this is only the size of the “event” item.

This metric is measured in Relay during ingestion.

bytes_ingested_event_minidump: Annotated<u64>

The size of the minidump ingested into Sentry.

The size is measured after applying all content- and transfer-encodings and thus independent of compression over the wire.

This metric is measured in Relay during ingestion.

bytes_ingested_event_applecrashreport: Annotated<u64>

The size of an apple crash report ingested into Sentry.

The size is measured after applying all content- and transfer-encodings and thus independent of compression over the wire.

This metric is measured in Relay during ingestion.

bytes_ingested_event_attachment: Annotated<u64>

The cumulative size of all additional attachments ingested into Sentry.

This is a sum of all all generic attachment payloads (excluding headers). These attachments are never processed and only potentially stored. Minidumps and apple crash reports are counted separately in their respective metrics.

This metric is measured in Relay during ingestion.

bytes_stored_event: Annotated<u64>

The size of the event payload as it is saved in node store.

For security reports, this is the size of the event derived from the original JSON. For processed events, such as native or javascript, this includes information derived during symbolication and internal meta data.

This metric is measured in Sentry after all processing has completed and when it is posted into node store.

bytes_stored_event_minidump: Annotated<u64>

The size of the minidump as it is saved in blob store.

Minidumps are not saved in two conditions. In this case, this number will be zero (missing):

1. The attachment feature is not enabled for an organization.
2. The option “Store Native Crash Reports” is disabled (default).

This metric is measured in Sentry after all processing has completed and when it is posted into node store.

bytes_stored_event_applecrashreport: Annotated<u64>

The size of the apple crash report as it is saved in blob store.

Apple crash reports are not saved in two conditions. In this case, this number will be zero (missing):

1. The attachment feature is not enabled for an organization.
2. The option “Store Native Crash Reports” is disabled (default).

This metric is measured in Sentry after all processing has completed and when it is posted into node store.

bytes_stored_event_attachment: Annotated<u64>

The cumulative size of all additional attachments as saved in blob store.

Attachments are not saved if the attachment feature is not enabled for the organization. In this case, this number will be zero (missing).

This metric is measured in Sentry after all processing has completed and when it is posted into node store.

ms_processing_symbolicator: Annotated<u64>

The number of milliseconds Symbolicator spent processing the native event.

This metric is measured in Symbolicator and reported in the native processing task. There are additional overheads polling symbolicator for the response, but the time reported from symbolicator reflects used resources most accurately.

ms_processing_proguard: Annotated<u64>

The number of milliseconds Sentry spent resolving proguard mappings for a java event.

This metric is measured in Sentry and reported in the java processing task.

ms_processing_jvm: Annotated<u64>

The number of milliseconds Sentry spent resolving sources for a java event.

This metric is measured in Sentry and reported in the java processing task.

ms_processing_sourcemaps: Annotated<u64>

The number of milliseconds sentry spent resolving minified stack traces for a javascript event.

This metric is measured in Sentry and reported in the javascript processing task.

flag_processing_error: Annotated<bool>

Whether there has been a processing error that likely impacts the usefulness of an event.

Example: malformed/unparseable debug information files.

This metric is measured in Sentry and should be reported in all processing tasks.

flag_processing_fatal: Annotated<bool>

Whether there has been a processing error that almost certainly renders the event unusuable.

Example: Minidump could not be parsed, but we do not drop the event as it may still contain context data and attachments, and we already billed the user anyway.

This metric is measured in Sentry and should be reported in all processing tasks.

Trait Implementations

impl Clone for Metrics

fn clone(&self) -> Metrics

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Metrics

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

Formats the value using the given formatter.

impl Default for Metrics

fn default() -> Metrics

Returns the “default value” for a type.

impl Empty for Metrics

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 Metrics

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

Creates a meta structure from an annotated boxed value.

impl IntoValue for Metrics

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 Metrics

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

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 Metrics