Enum Reason 

#[non_exhaustive]
pub enum Reason {
    SendError,
    InternalSdkError,
    NetworkError,
    RatelimitBackoff,
    QueueOverflow,
    BufferOverflow,
    EventProcessor,
    BeforeSend,
    SampleRate,
}

The reason why a telemetry item was discarded.

Valid discard reasons are listed in the develop docs; this enum may only define a subset of these data categories, but we will add further categories as we begin using them in the SDK.

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

SendError

Error when sending the envelope (e.g. non-2xx HTTP response).

InternalSdkError

An internal error in the SDK, which does not fit under any other category.

NetworkError

A network error occurred while sending the envelope.

RatelimitBackoff

The SDK is backing off due to a rate limit.

QueueOverflow

An internal queue overflowed (e.g. the transport queue).

BufferOverflow

An SDK internal buffer overflowed.

EventProcessor

An event was dropped by an event processor.

BeforeSend

An event was dropped by a before_send callback.

SampleRate

An event was dropped because of error event sampling.

Trait Implementations

impl Clone for Reason

fn clone(&self) -> Reason

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for Reason

impl Debug for Reason

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Reason

fn deserialize<__D>( __deserializer: __D, ) -> Result<Reason, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for Reason

impl Hash for Reason

fn hash<__H>(&self, state: &mut __H)

where __H: Hasher,

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl IndexedEnum for Reason

const VARIANTS: &'static [Reason]

A slice containing all the variants in index order.

fn as_index(&self) -> usize

Returns this variant’s unique zero-based index.

impl PartialEq for Reason

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

fn serialize<__S>( &self, __serializer: __S, ) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for Reason