Enum EventArray 

pub enum EventArray {
    Logs(Vec<LogEvent>),
    Metrics(Vec<Metric>),
    Traces(Vec<TraceEvent>),
}

An array of one of the Event variants exclusively.

Variants

Logs(Vec<LogEvent>)

An array of type LogEvent

Metrics(Vec<Metric>)

An array of type Metric

Traces(Vec<TraceEvent>)

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<EventArray>

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<(), Error>

Formats the value using the given formatter.

impl Encodable for EventArray

fn encode<B>( self, buffer: &mut B, ) -> Result<(), <EventArray as Encodable>::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() -> <EventArray as Encodable>::Metadata

Gets the version metadata associated with this encoding scheme.

fn can_decode(metadata: <EventArray as Encodable>::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: <EventArray as Encodable>::Metadata, buffer: B, ) -> Result<EventArray, <EventArray as Encodable>::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) -> <EventArray as EventContainer>::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: &EventArray) -> 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) -> EventArray

Converts to this type from the input type.

impl From<EventArray> for EventArray

fn from(events: EventArray) -> EventArray

Converts to this type from the input type.

impl From<EventArray> for EventArray

fn from(events: EventArray) -> EventArray

Converts to this type from the input type.

impl From<LogEvent> for EventArray

fn from(log: LogEvent) -> EventArray

Converts to this type from the input type.

impl From<Metric> for EventArray

fn from(metric: Metric) -> EventArray

Converts to this type from the input type.

impl From<SourceSenderItem> for EventArray

fn from(val: SourceSenderItem) -> EventArray

Converts to this type from the input type.

impl From<TraceEvent> for EventArray

fn from(trace: TraceEvent) -> EventArray

Converts to this type from the input type.

impl From<Vec<LogEvent>> for EventArray

fn from(array: Vec<LogEvent>) -> EventArray

Converts to this type from the input type.

impl From<Vec<Metric>> for EventArray

fn from(array: Vec<Metric>) -> EventArray

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 StreamSink<EventArray> for HumioMetricsSink

fn run<'life0, 'async_trait>( self: Box<Self>, input: BoxStream<'life0, EventArray>, ) -> Pin<Box<dyn Future<Output = Result<(), ()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

impl StructuralPartialEq for EventArray