Enum vector::sinks::prelude::Event

pub enum Event {
    Log(LogEvent),
    Metric(Metric),
    Trace(TraceEvent),
}

Variants

Log(LogEvent)

Metric(Metric)

Trace(TraceEvent)

Implementations

impl Event

pub fn as_log(&self) -> &LogEvent

Return self as a LogEvent

Panics

This function panics if self is anything other than an Event::Log.

pub fn as_mut_log(&mut self) -> &mut LogEvent

Return self as a mutable LogEvent

Panics

This function panics if self is anything other than an Event::Log.

pub fn into_log(self) -> LogEvent

Coerces self into a LogEvent

Panics

This function panics if self is anything other than an Event::Log.

pub fn try_into_log(self) -> Option<LogEvent>

Fallibly coerces self into a LogEvent

If the event is a LogEvent, then Some(log_event) is returned, otherwise None.

pub fn maybe_as_log(&self) -> Option<&LogEvent>

Return self as a LogEvent if possible

If the event is a LogEvent, then Some(&log_event) is returned, otherwise None.

pub fn as_metric(&self) -> &Metric

Return self as a Metric

Panics

This function panics if self is anything other than an Event::Metric.

pub fn as_mut_metric(&mut self) -> &mut Metric

Return self as a mutable Metric

Panics

This function panics if self is anything other than an Event::Metric.

pub fn into_metric(self) -> Metric

Coerces self into Metric

Panics

This function panics if self is anything other than an Event::Metric.

pub fn try_into_metric(self) -> Option<Metric>

Fallibly coerces self into a Metric

If the event is a Metric, then Some(metric) is returned, otherwise None.

pub fn as_trace(&self) -> &TraceEvent

Return self as a TraceEvent

Panics

This function panics if self is anything other than an Event::Trace.

pub fn as_mut_trace(&mut self) -> &mut TraceEvent

Return self as a mutable TraceEvent

Panics

This function panics if self is anything other than an Event::Trace.

pub fn into_trace(self) -> TraceEvent

Coerces self into a TraceEvent

Panics

This function panics if self is anything other than an Event::Trace.

pub fn try_into_trace(self) -> Option<TraceEvent>

Fallibly coerces self into a TraceEvent

If the event is a TraceEvent, then Some(trace) is returned, otherwise None.

pub fn metadata(&self) -> &EventMetadata

pub fn metadata_mut(&mut self) -> &mut EventMetadata

pub fn into_metadata(self) -> EventMetadata

Destroy the event and return the metadata.

pub fn with_batch_notifier(self, batch: &BatchNotifier) -> Event

pub fn with_batch_notifier_option(self, batch: &Option<BatchNotifier>) -> Event

pub fn source_id(&self) -> Option<&Arc<ComponentKey>>

Returns a reference to the event metadata source.

pub fn set_source_id(&mut self, source_id: Arc<ComponentKey>)

Sets the source_id in the event metadata to the provided value.

pub fn set_upstream_id(&mut self, upstream_id: Arc<OutputId>)

Sets the upstream_id in the event metadata to the provided value.

pub fn set_source_type(&mut self, source_type: &'static str)

Sets the source_type in the event metadata to the provided value.

pub fn with_source_id(self, source_id: Arc<ComponentKey>) -> Event

Sets the source_id in the event metadata to the provided value.

pub fn with_source_type(self, source_type: &'static str) -> Event

Sets the source_type in the event metadata to the provided value.

pub fn with_upstream_id(self, upstream_id: Arc<OutputId>) -> Event

Sets the upstream_id in the event metadata to the provided value.

pub fn from_json_value( value: Value, log_namespace: LogNamespace, ) -> Result<Event, Box<dyn Error + Sync + Send>>

Creates an Event from a JSON value.

Errors

If a non-object JSON value is passed in with the Legacy namespace, this will return an error.

Trait Implementations

impl AddBatchNotifier for Event

fn add_batch_notifier(&mut self, batch: BatchNotifier)

Adds a single shared batch notifier to this type.

impl ByteSizeOf for Event

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 Event

fn clone(&self) -> Event

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Event

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Event

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Encoder<Event> for (Transformer, Encoder<()>)

fn encode_input( &self, event: Event, writer: &mut dyn Write, ) -> Result<(usize, GroupedCountByteSize)>

Encodes the input into the provided writer.

impl Encoder<Event> for Encoder<()>

type Error = Error

The type of encoding errors.

fn encode( &mut self, event: Event, buffer: &mut BytesMut, ) -> Result<(), Self::Error>

Encodes a frame into the buffer provided.

impl Encoder<Event> for Encoder<Framer>

type Error = Error

The type of encoding errors.

fn encode( &mut self, event: Event, buffer: &mut BytesMut, ) -> Result<(), Self::Error>

Encodes a frame into the buffer provided.

impl EstimatedJsonEncodedSizeOf for Event

fn estimated_json_encoded_size_of(&self) -> JsonSize

impl EventContainer for Event

type IntoIter = Once<Event>

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

fn len(&self) -> usize

The number of events in this container.

fn is_empty(&self) -> bool

Is this container empty?

fn into_events(self) -> <Event as EventContainer>::IntoIter

Turn this container into an iterator over Event.

impl EventCount for Event

fn event_count(&self) -> usize

impl<'a> EventDataEq<Event> for EventRef<'a>

fn event_data_eq(&self, that: &Event) -> bool

impl EventDataEq for Event

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

impl Finalizable for Event

fn take_finalizers(&mut self) -> EventFinalizers

Consumes the finalizers of this object.

impl<'a> From<&'a Event> for EventRef<'a>

fn from(event: &'a Event) -> EventRef<'a>

Converts to this type from the input type.

impl<'a> From<&'a mut Event> for EventMutRef<'a>

fn from(event: &'a mut Event) -> EventMutRef<'a>

Converts to this type from the input type.

impl From<Event> for Event

fn from(event: Event) -> Event

Converts to this type from the input type.

impl From<Event> for EventArray

fn from(event: Event) -> EventArray

Converts to this type from the input type.

impl From<Event> for EventWrapper

fn from(event: Event) -> EventWrapper

Converts to this type from the input type.

impl From<Event> for WithMetadata<Event>

fn from(event: Event) -> WithMetadata<Event>

Converts to this type from the input type.

impl From<Event> for WithMetadata<EventWrapper>

fn from(event: Event) -> WithMetadata<EventWrapper>

Converts to this type from the input type.

impl From<EventWrapper> for Event

fn from(proto: EventWrapper) -> Event

Converts to this type from the input type.

impl From<LogEvent> for Event

fn from(log: LogEvent) -> Event

Converts to this type from the input type.

impl From<Metric> for Event

fn from(metric: Metric) -> Event

Converts to this type from the input type.

impl From<TraceEvent> for Event

fn from(trace: TraceEvent) -> Event

Converts to this type from the input type.

impl FromLua for Event

fn from_lua(value: Value, lua: &Lua) -> Result<Event, Error>

Performs the conversion.

impl GetEventCountTags for Event

fn get_tags(&self) -> TaggedEventsSent

impl ItemBatchSize<Event> for HttpJsonBatchSizer

fn size(&self, item: &Event) -> usize

The size of an individual item in a batch.

impl MaybeAsLogMut for Event

fn maybe_as_log_mut(&mut self) -> Option<&mut LogEvent>

impl PartialEq for Event

fn eq(&self, other: &Event) -> 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 RequestBuilder<Event> for DatadogEventsRequestBuilder

type Metadata = Metadata

type Events = Event

type Encoder = (Transformer, Encoder<()>)

type Payload = Bytes

type Request = DatadogEventsRequest

type Error = Error

fn compression(&self) -> Compression

Gets the compression algorithm used by this request builder.

fn encoder(&self) -> &Self::Encoder

Gets the encoder used by this request builder.

fn split_input( &self, event: Event, ) -> (Self::Metadata, RequestMetadataBuilder, Self::Events)

Splits apart the input into the metadata and event portions.

fn build_request( &self, metadata: Self::Metadata, request_metadata: RequestMetadata, payload: EncodeResult<Self::Payload>, ) -> Self::Request

Builds a request for the given metadata and payload.

fn encode_events( &self, events: Self::Events, ) -> Result<EncodeResult<Self::Payload>, Self::Error>

impl Serialize for Event

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<T, B, RL> Sink<Event> for BatchedHttpSink<T, B, RL>

where B: Batch, B::Output: ByteSizeOf + Clone + Send + 'static, T: HttpSink<Input = B::Input, Output = B::Output>, RL: RetryLogic<Response = Response<Bytes>> + Send + 'static,

type Error = Box<dyn Error + Sync + Send>

The type of value produced by the sink when an error occurs.

fn poll_ready( self: Pin<&mut Self>, cx: &mut Context<'_>, ) -> Poll<Result<(), Self::Error>>

Attempts to prepare the Sink to receive a value.

fn start_send(self: Pin<&mut Self>, event: Event) -> Result<(), Self::Error>

Begin the process of sending a value to the sink. Each call to this function must be preceded by a successful call to poll_ready which returned Poll::Ready(Ok(())).

fn poll_flush( self: Pin<&mut Self>, cx: &mut Context<'_>, ) -> Poll<Result<(), Self::Error>>

Flush any remaining output from this sink.

fn poll_close( self: Pin<&mut Self>, cx: &mut Context<'_>, ) -> Poll<Result<(), Self::Error>>

Flush any remaining output and close this sink, if necessary.

impl<T, B, K, RL> Sink<Event> for PartitionHttpSink<T, B, K, RL>

where B: Batch, B::Output: ByteSizeOf + Clone + Send + 'static, B::Input: Partition<K>, K: Hash + Eq + Clone + Send + 'static, T: HttpSink<Input = B::Input, Output = B::Output>, RL: RetryLogic<Response = Response<Bytes>> + Send + 'static,

type Error = Box<dyn Error + Sync + Send>

The type of value produced by the sink when an error occurs.

fn poll_ready( self: Pin<&mut Self>, cx: &mut Context<'_>, ) -> Poll<Result<(), Self::Error>>

Attempts to prepare the Sink to receive a value.

fn start_send(self: Pin<&mut Self>, event: Event) -> Result<(), Self::Error>

Begin the process of sending a value to the sink. Each call to this function must be preceded by a successful call to poll_ready which returned Poll::Ready(Ok(())).

fn poll_flush( self: Pin<&mut Self>, cx: &mut Context<'_>, ) -> Poll<Result<(), Self::Error>>

Flush any remaining output from this sink.

fn poll_close( self: Pin<&mut Self>, cx: &mut Context<'_>, ) -> Poll<Result<(), Self::Error>>

Flush any remaining output and close this sink, if necessary.

impl<Svc, RB> StreamSink<Event> for AzureBlobSink<Svc, RB>

where Svc: Service<RB::Request> + Send + 'static, Svc::Future: Send + 'static, Svc::Response: DriverResponse + Send + 'static, Svc::Error: Debug + Into<Error> + Send, RB: RequestBuilder<(String, Vec<Event>)> + Send + Sync + 'static, RB::Error: Display + Send, RB::Request: Finalizable + MetaDescriptive + Send,

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

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

impl<Svc, RB> StreamSink<Event> for ChronicleSink<Svc, RB>

where Svc: Service<RB::Request> + Send + 'static, Svc::Future: Send + 'static, Svc::Response: DriverResponse + Send + 'static, Svc::Error: Debug + Into<Error> + Send, RB: RequestBuilder<(ChroniclePartitionKey, Vec<Event>)> + Send + Sync + 'static, RB::Error: Display + Send, RB::Request: Finalizable + MetaDescriptive + Send,

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

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

impl<S> StreamSink<Event> for DatadogEventsSink<S>

where S: Service<DatadogEventsRequest> + Send + 'static, S::Future: Send + 'static, S::Response: DriverResponse + Send + 'static, S::Error: Debug + Into<Error> + Send,

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

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

impl<S> StreamSink<Event> for ElasticsearchSink<S>

where S: Service<ElasticsearchRequest> + Send + 'static, S::Future: Send + 'static, S::Response: DriverResponse + Send + 'static, S::Error: Debug + Into<Error> + Send,

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

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

impl StreamSink<Event> for FileSink

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

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

impl<Svc, RB> StreamSink<Event> for GcsSink<Svc, RB>

where Svc: Service<RB::Request> + Send + 'static, Svc::Future: Send + 'static, Svc::Response: DriverResponse + Send + 'static, Svc::Error: Debug + Into<Error> + Send, RB: RequestBuilder<(String, Vec<Event>)> + Send + Sync + 'static, RB::Error: Display + Send, RB::Request: Finalizable + MetaDescriptive + Send,

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

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

impl<S, R> StreamSink<Event> for KinesisSink<S, R>

where S: Service<BatchKinesisRequest<R>> + Send + 'static, S::Future: Send + 'static, S::Response: DriverResponse + Send + 'static, S::Error: Debug + Into<Error> + Send, R: Record + Send + Sync + Unpin + Clone + 'static,

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

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

impl<S> StreamSink<Event> for LogSink<S>

where S: Service<LogApiRequest> + Send + 'static, S::Future: Send + 'static, S::Response: DriverResponse + Send + 'static, S::Error: Debug + Into<Error> + Send,

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

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

impl<Svc> StreamSink<Event> for OpenDalSink<Svc>

where Svc: Service<OpenDalRequest> + Send + 'static, Svc::Future: Send + 'static, Svc::Response: DriverResponse + Send + 'static, Svc::Error: Debug + Into<Error> + Send,

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

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

impl<Svc, RB> StreamSink<Event> for S3Sink<Svc, RB>

where Svc: Service<RB::Request> + Send + 'static, Svc::Future: Send + 'static, Svc::Response: DriverResponse + Send + 'static, Svc::Error: Debug + Into<Error> + Send, RB: RequestBuilder<(S3PartitionKey, Vec<Event>)> + Send + Sync + 'static, RB::Error: Display + Send, RB::Request: Finalizable + MetaDescriptive + Send,

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

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

impl TaskTransform<Event> for Aggregate

fn transform( self: Box<Self>, input_rx: Pin<Box<dyn Stream<Item = Event> + Send>>, ) -> Pin<Box<dyn Stream<Item = Event> + Send>>

where Self: 'static,

fn transform_events( self: Box<Self>, task: Pin<Box<dyn Stream<Item = Event> + Send>>, ) -> Pin<Box<dyn Stream<Item = Event> + Send>>

where T: From<Event>, <T as EventContainer>::IntoIter: Send,

Wrap the transform task to process and emit individual events. This is used to simplify testing task transforms.

impl TaskTransform<Event> for Dedupe

fn transform( self: Box<Self>, task: Pin<Box<dyn Stream<Item = Event> + Send>>, ) -> Pin<Box<dyn Stream<Item = Event> + Send>>

where Self: 'static,

fn transform_events( self: Box<Self>, task: Pin<Box<dyn Stream<Item = Event> + Send>>, ) -> Pin<Box<dyn Stream<Item = Event> + Send>>

where T: From<Event>, <T as EventContainer>::IntoIter: Send,

Wrap the transform task to process and emit individual events. This is used to simplify testing task transforms.

impl TaskTransform<Event> for Ec2MetadataTransform

fn transform( self: Box<Self>, task: Pin<Box<dyn Stream<Item = Event> + Send>>, ) -> Pin<Box<dyn Stream<Item = Event> + Send>>

where Self: 'static,

fn transform_events( self: Box<Self>, task: Pin<Box<dyn Stream<Item = Event> + Send>>, ) -> Pin<Box<dyn Stream<Item = Event> + Send>>

where T: From<Event>, <T as EventContainer>::IntoIter: Send,

Wrap the transform task to process and emit individual events. This is used to simplify testing task transforms.

impl TaskTransform<Event> for Lua

fn transform( self: Box<Self>, task: Pin<Box<dyn Stream<Item = Event> + Send>>, ) -> Pin<Box<dyn Stream<Item = Event> + Send>>

where Self: 'static,

fn transform_events( self: Box<Self>, task: Pin<Box<dyn Stream<Item = Event> + Send>>, ) -> Pin<Box<dyn Stream<Item = Event> + Send>>

where T: From<Event>, <T as EventContainer>::IntoIter: Send,

Wrap the transform task to process and emit individual events. This is used to simplify testing task transforms.

impl TaskTransform<Event> for Reduce

fn transform( self: Box<Self>, input_rx: Pin<Box<dyn Stream<Item = Event> + Send>>, ) -> Pin<Box<dyn Stream<Item = Event> + Send>>

where Self: 'static,

fn transform_events( self: Box<Self>, task: Pin<Box<dyn Stream<Item = Event> + Send>>, ) -> Pin<Box<dyn Stream<Item = Event> + Send>>

where T: From<Event>, <T as EventContainer>::IntoIter: Send,

Wrap the transform task to process and emit individual events. This is used to simplify testing task transforms.

impl TaskTransform<Event> for TagCardinalityLimit

fn transform( self: Box<Self>, task: Pin<Box<dyn Stream<Item = Event> + Send>>, ) -> Pin<Box<dyn Stream<Item = Event> + Send>>

where Self: 'static,

fn transform_events( self: Box<Self>, task: Pin<Box<dyn Stream<Item = Event> + Send>>, ) -> Pin<Box<dyn Stream<Item = Event> + Send>>

where T: From<Event>, <T as EventContainer>::IntoIter: Send,

Wrap the transform task to process and emit individual events. This is used to simplify testing task transforms.

impl<C, I> TaskTransform<Event> for Throttle<C, I>

where C: Clock<Instant = I> + Send + 'static + Clone, I: Reference + Send + 'static,

fn transform( self: Box<Self>, input_rx: Pin<Box<dyn Stream<Item = Event> + Send>>, ) -> Pin<Box<dyn Stream<Item = Event> + Send>>

where Self: 'static,

fn transform_events( self: Box<Self>, task: Pin<Box<dyn Stream<Item = Event> + Send>>, ) -> Pin<Box<dyn Stream<Item = Event> + Send>>

where T: From<Event>, <T as EventContainer>::IntoIter: Send,

Wrap the transform task to process and emit individual events. This is used to simplify testing task transforms.

impl TryInto<Value> for Event

type Error = Error

The type returned in the event of a conversion error.

fn try_into(self) -> Result<Value, <Event as TryInto<Value>>::Error>

Performs the conversion.

impl StructuralPartialEq for Event