Struct ManagedEnvelope

pub struct ManagedEnvelope { /* private fields */ }

Tracks the lifetime of an [Envelope] in Relay.

The managed envelope accompanies envelopes through the processing pipeline in Relay and ensures that outcomes are recorded when the Envelope is dropped. They can be dropped in one of three ways:

• By calling accept. Responsibility of the envelope has been transferred to another service, and no further outcomes need to be recorded.
• By calling reject. The entire envelope was dropped, and the outcome specifies the reason.
• By dropping the managed envelope. This indicates an issue or a bug and raises the "internal" outcome. There should be additional error handling to report an error to Sentry.

The managed envelope also holds a processing queue permit which is used for backpressure management. It is automatically reclaimed when the context is dropped along with the envelope.

Implementations

impl ManagedEnvelope

pub fn new( envelope: Box<Envelope>, outcome_aggregator: Addr<TrackOutcome>, ) -> Self

Computes a managed envelope from the given envelope and binds it to the processing queue.

To provide additional scoping, use ManagedEnvelope::scope.

pub fn envelope(&self) -> &Envelope

Returns a reference to the contained [Envelope].

pub fn envelope_mut(&mut self) -> &mut Envelope

Returns a mutable reference to the contained [Envelope].

pub fn into_envelope(self) -> Box<Envelope>

Consumes itself returning the managed envelope.

pub fn into_processed(self) -> TypedEnvelope<Processed>

Converts current managed envelope into processed envelope.

Once it’s marked processed it can be submitted to upstream.

pub fn update(&mut self) -> &mut Self

Update the context with envelope information.

This updates the item summary as well as the event id.

pub fn retain_items<F>(&mut self, f: F)

where F: FnMut(&mut Item) -> ItemAction,

Retains or drops items based on the ItemAction.

This method operates in place and preserves the order of the retained items.

pub fn drop_items_silently(&mut self)

Drops every item in the envelope.

pub fn scope(&mut self, scoping: Scoping) -> &mut Self

Re-scopes this context to the given scoping.

pub fn reject_event(&mut self, outcome: Outcome)

Removes event item(s) and logs an outcome.

Note: This function relies on the envelope summary being correct.

pub fn track_outcome( &self, outcome: Outcome, category: DataCategory, quantity: usize, )

Records an outcome scoped to this envelope’s context.

This managed envelope should be updated using update soon after this operation to ensure that subsequent outcomes are consistent.

pub fn accept(self)

Accepts the envelope and drops the context.

This should be called if the envelope has been accepted by the upstream, which means that the responsibility for logging outcomes has been moved. This function will not log any outcomes.

pub fn reject(&mut self, outcome: Outcome)

Records rejection outcomes for all items stored in this context.

This does not send outcomes for empty envelopes or request-only contexts.

pub fn scoping(&self) -> Scoping

Returns scoping stored in this context.

pub fn partition_key(&self) -> Option<u32>

Returns the partition key, which is set on upstream requests in the X-Sentry-Relay-Shard header.

pub fn set_partition_key(&mut self, partition_key: Option<u32>) -> &mut Self

Sets a new Self::partition_key.

pub fn meta(&self) -> &RequestMeta

Returns the contained original request meta.

pub fn estimated_size(&self) -> usize

Returns estimated size of this envelope.

This is just an estimated size, which in reality can be somewhat bigger, depending on the list of additional attributes allocated on all of the inner types.

NOTE: Current implementation counts in only the size of the items payload and stack allocated parts of [Envelope] and ManagedEnvelope. All the heap allocated fields within early mentioned types are skipped.

pub fn received_at(&self) -> DateTime<Utc>

Returns the time at which the envelope was received at this Relay.

This is the date time equivalent to start_time.

pub fn age(&self) -> Duration

Returns the time elapsed in seconds since the envelope was received by this Relay.

In case the elapsed time is negative, it is assumed that no time elapsed.

Trait Implementations

impl Debug for ManagedEnvelope

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

Formats the value using the given formatter.

impl Drop for ManagedEnvelope

fn drop(&mut self)

Executes the destructor for this type.

impl<G> From<TypedEnvelope<G>> for ManagedEnvelope

fn from(value: TypedEnvelope<G>) -> Self

Converts to this type from the input type.