Enum EventArray 

pub enum EventArray {
    Logs(LogArray),
    Metrics(MetricArray),
    Traces(TraceArray),
}

An array of one of the Event variants exclusively.

Variants

Logs(LogArray)

An array of type LogEvent

Metrics(MetricArray)

An array of type Metric

Traces(TraceArray)

An array of type TraceEvent

Implementations

impl EventArray

pub fn iter_events(&self) -> impl Iterator<Item = EventRef<'_>>

Iterate over references to this array’s events.

pub fn iter_events_mut(&mut self) -> impl Iterator<Item = EventMutRef<'_>>

Iterate over mutable references to this array’s events.

pub fn iter_logs_mut(&mut self) -> impl Iterator<Item = &mut LogEvent>

Iterate over references to the logs in this array.

pub fn for_each_metadata_mut(&mut self, f: impl FnMut(&mut EventMetadata))

Applies a closure to each event’s metadata in this array.

Trait Implementations

impl AddBatchNotifier for EventArray

fn add_batch_notifier(&mut self, batch: BatchNotifier)

Adds a single shared batch notifier to this type.

impl Bufferable for EventArray

fn is_fully_encodable(&self) -> bool

Reuses the same budget walk as the encode-time gate, so the routing decision and the eventual encode can never disagree about what is persistable.

fn filter_unencodable(self) -> Option<Self>

Drops any sub-items that cannot be persisted by the calling backend (e.g. due to format-imposed nesting depth limits), reporting them as dropped via the appropriate telemetry. Returns None if nothing remains worth writing.

impl ByteSizeOf for EventArray

fn allocated_bytes(&self) -> usize

Returns the allocated bytes of this type

fn size_of(&self) -> usize

Returns the in-memory size of this type

impl Clone for EventArray

fn clone(&self) -> EventArray

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for EventArray

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

Formats the value using the given formatter.

impl Encodable for EventArray

fn encode<B>(self, buffer: &mut B) -> Result<(), Self::EncodeError>

where B: BufMut,

Errors

Returns EncodeError::NestingTooDeep if any contained event’s value or metadata exceeds MAX_VALUE_NESTING_FRAMES. This is all-or-nothing: a single over-budget event fails the entire batch, because a partially-encoded EventArray reaching disk would trip prost’s recursion limit on decode and corrupt the buffer.

Callers that want graceful per-item drop with telemetry and EventStatus::Rejected must run [Bufferable::filter_unencodable] first. SenderAdapter::send/try_send already does this on the disk-v2 path, so the NestingTooDeep arm is unreachable from any current production call site — it is defense-in-depth for a future caller that bypasses SenderAdapter.

Returns EncodeError::BufferTooSmall if the buffer cannot hold the encoded output.

type Metadata = EventEncodableMetadata

type EncodeError = EncodeError

type DecodeError = DecodeError

fn get_metadata() -> Self::Metadata

Gets the version metadata associated with this encoding scheme.

fn can_decode(metadata: Self::Metadata) -> bool

Whether or not this encoding scheme can understand and successfully decode a value based on the given version metadata that was bundled with the value.

fn decode<B>( metadata: Self::Metadata, buffer: B, ) -> Result<Self, Self::DecodeError>

where B: Buf + Clone,

Attempts to decode an instance of this type from the given buffer and metadata.

fn encoded_size(&self) -> Option<usize>

Gets the encoded size, in bytes, of this value, if available.

impl EstimatedJsonEncodedSizeOf for EventArray

fn estimated_json_encoded_size_of(&self) -> JsonSize

impl EventContainer for EventArray

type IntoIter = EventArrayIntoIter

The type of Iterator used to turn this container into events.

fn len(&self) -> usize

The number of events in this container.

fn into_events(self) -> Self::IntoIter

Turn this container into an iterator over Event.

fn is_empty(&self) -> bool

Is this container empty?

impl EventCount for EventArray

fn event_count(&self) -> usize

impl EventDataEq for EventArray

fn event_data_eq(&self, other: &Self) -> bool

impl Finalizable for EventArray

fn take_finalizers(&mut self) -> EventFinalizers

Consumes the finalizers of this object.

fn take_finalizer_groups(&mut self) -> EventFinalizerGroups

Consumes this object’s finalizers while preserving independent finalizer groups.

impl From<Event> for EventArray

fn from(event: Event) -> Self

Converts to this type from the input type.

impl From<EventArray> for EventArray

fn from(events: EventArray) -> Self

Converts to this type from the input type.

impl From<EventArray> for EventArray

fn from(events: EventArray) -> Self

Converts to this type from the input type.

impl From<LogEvent> for EventArray

fn from(log: LogEvent) -> Self

Converts to this type from the input type.

impl From<Metric> for EventArray

fn from(metric: Metric) -> Self

Converts to this type from the input type.

impl From<SourceSenderItem> for EventArray

fn from(val: SourceSenderItem) -> Self

Converts to this type from the input type.

impl From<TraceEvent> for EventArray

fn from(trace: TraceEvent) -> Self

Converts to this type from the input type.

impl From<Vec<LogEvent>> for EventArray

fn from(array: LogArray) -> Self

Converts to this type from the input type.

impl From<Vec<Metric>> for EventArray

fn from(array: MetricArray) -> Self

Converts to this type from the input type.

impl GroupedFinalizable for EventArray

fn merge_finalizer_groups(&mut self, finalizers: EventFinalizerGroups)

Merges grouped finalizers back into this object.

impl PartialEq for EventArray

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