Struct vector::sinks::util::processed_event::ProcessedEvent

pub struct ProcessedEvent<E, M> {
    pub event: E,
    pub metadata: M,
}

An event alongside metadata from preprocessing. This is useful for sinks like Splunk HEC that process events prior to encoding.

Fields

event: E

metadata: M

Trait Implementations

impl<E, M> ByteSizeOf for ProcessedEvent<E, M>

where E: ByteSizeOf, M: ByteSizeOf,

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<E, M> EstimatedJsonEncodedSizeOf for ProcessedEvent<E, M>

where E: EstimatedJsonEncodedSizeOf,

fn estimated_json_encoded_size_of(&self) -> JsonSize

impl EventCount for ProcessedEvent<LogEvent, HecLogsProcessedEventMetadata>

fn event_count(&self) -> usize

impl EventCount for ProcessedEvent<Metric, HecMetricsProcessedEventMetadata>

fn event_count(&self) -> usize

impl<E, M> Finalizable for ProcessedEvent<E, M>

where E: Finalizable,

fn take_finalizers(&mut self) -> EventFinalizers

Consumes the finalizers of this object.

impl<E, M> GetEventCountTags for ProcessedEvent<E, M>

where E: GetEventCountTags,

fn get_tags(&self) -> TaggedEventsSent

impl<E, M> MaybeAsLogMut for ProcessedEvent<E, M>

where E: MaybeAsLogMut,

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

impl<R> RequestBuilder<ProcessedEvent<LogEvent, KinesisKey>> for KinesisRequestBuilder<R>

where R: Record,

type Metadata = KinesisMetadata

type Events = Event

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

type Payload = Bytes

type Request = KinesisRequest<R>

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, processed_event: KinesisProcessedEvent, ) -> (Self::Metadata, RequestMetadataBuilder, Self::Events)

Splits apart the input into the metadata and event portions.

fn build_request( &self, kinesis_metadata: Self::Metadata, 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<E, M> Serialize for ProcessedEvent<E, M>

where E: Serialize, M: Serialize,

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

where __S: Serializer,

Serialize this value into the given Serde serializer.