Struct vector::event::LogEvent

pub struct LogEvent { /* private fields */ }

Implementations

impl LogEvent

pub fn from_str_legacy(msg: impl Into<String>) -> LogEvent

This used to be the implementation for LogEvent::from(&'str), but this is now only valid for LogNamespace::Legacy

pub fn from_bytes_legacy(msg: &Bytes) -> LogEvent

This used to be the implementation for LogEvent::from(Bytes), but this is now only valid for LogNamespace::Legacy

pub fn value(&self) -> &Value

pub fn value_mut(&mut self) -> &mut Value

pub fn metadata(&self) -> &EventMetadata

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

pub fn namespace(&self) -> LogNamespace

This detects the log namespace used at runtime by checking for the existence of the read-only “vector” metadata, which only exists (and is required to exist) with the Vector log namespace.

impl LogEvent

pub fn new_with_metadata(metadata: EventMetadata) -> LogEvent

pub fn from_parts(value: Value, metadata: EventMetadata) -> LogEvent

Create a LogEvent from a Value and EventMetadata

pub fn from_map( map: BTreeMap<KeyString, Value>, metadata: EventMetadata, ) -> LogEvent

Create a LogEvent from an ObjectMap and EventMetadata

pub fn into_parts(self) -> (Value, EventMetadata)

Convert a LogEvent into a tuple of its components

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

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

pub fn add_finalizer(&mut self, finalizer: EventFinalizer)

pub fn parse_path_and_get_value( &self, path: impl AsRef<str>, ) -> Result<Option<&Value>, PathParseError>

Parse the specified path and if there are no parsing errors, attempt to get a reference to a value.

Errors

Will return an error if path parsing failed.

pub fn get<'a>(&self, key: impl TargetPath<'a>) -> Option<&Value>

pub fn get_by_meaning(&self, meaning: impl AsRef<str>) -> Option<&Value>

Retrieves the value of a field based on it’s meaning. This will first check if the value has previously been dropped. It is worth being aware that if the field has been dropped and then somehow re-added, we still fetch the dropped value here.

pub fn get_mut_by_meaning( &mut self, meaning: impl AsRef<str>, ) -> Option<&mut Value>

Retrieves the mutable value of a field based on it’s meaning. Note that this does not check the dropped fields, unlike get_by_meaning, since the purpose of the mutable reference is to be able to modify the value and modifying the dropped fields has no effect on the resulting event.

pub fn find_key_by_meaning( &self, meaning: impl AsRef<str>, ) -> Option<&OwnedTargetPath>

Retrieves the target path of a field based on the specified meaning.

pub fn get_mut<'a>(&mut self, path: impl TargetPath<'a>) -> Option<&mut Value>

pub fn contains<'a>(&self, path: impl TargetPath<'a>) -> bool

pub fn parse_path_and_insert( &mut self, path: impl AsRef<str>, value: impl Into<Value>, ) -> Result<Option<Value>, PathParseError>

Parse the specified path and if there are no parsing errors, attempt to insert the specified value.

Errors

Will return an error if path parsing failed.

pub fn insert<'a>( &mut self, path: impl TargetPath<'a>, value: impl Into<Value>, ) -> Option<Value>

pub fn maybe_insert<'a>( &mut self, path: Option<impl TargetPath<'a>>, value: impl Into<Value>, )

pub fn try_insert<'a>( &mut self, path: impl TargetPath<'a>, value: impl Into<Value>, )

pub fn rename_key<'a>( &mut self, from: impl TargetPath<'a>, to: impl TargetPath<'a>, )

Rename a key

If to_key already exists in the structure its value will be overwritten.

pub fn remove<'a>(&mut self, path: impl TargetPath<'a>) -> Option<Value>

pub fn remove_prune<'a>( &mut self, path: impl TargetPath<'a>, prune: bool, ) -> Option<Value>

pub fn keys(&self) -> Option<impl Iterator<Item = KeyString>>

pub fn all_event_fields( &self, ) -> Option<impl Iterator<Item = (KeyString, &Value)> + Serialize>

If the event root value is a map, build and return an iterator to event field and value pairs. TODO: Ideally this should return target paths to be consistent with other LogEvent methods.

pub fn all_event_fields_skip_array_elements( &self, ) -> Option<impl Iterator<Item = (KeyString, &Value)> + Serialize>

Similar to LogEvent::all_event_fields, but doesn’t traverse individual array elements.

pub fn all_metadata_fields( &self, ) -> Option<impl Iterator<Item = (KeyString, &Value)> + Serialize>

If the metadata root value is a map, build and return an iterator to metadata field and value pairs. TODO: Ideally this should return target paths to be consistent with other LogEvent methods.

pub fn convert_to_fields( &self, ) -> impl Iterator<Item = (KeyString, &Value)> + Serialize

Returns an iterator of all fields if the value is an Object. Otherwise, a single field is returned with a “message” key. Field names that are could be interpreted as alternate paths (i.e. containing periods, square brackets, etc) are quoted.

pub fn convert_to_fields_unquoted( &self, ) -> impl Iterator<Item = (KeyString, &Value)> + Serialize

Returns an iterator of all fields if the value is an Object. Otherwise, a single field is returned with a “message” key. Field names are not quoted.

pub fn is_empty_object(&self) -> bool

pub fn as_map(&self) -> Option<&BTreeMap<KeyString, Value>>

pub fn as_map_mut(&mut self) -> Option<&mut BTreeMap<KeyString, Value>>

pub fn merge(&mut self, incoming: LogEvent, fields: &[impl AsRef<str>])

Merge all fields specified at fields from incoming to current. Note that fields containing dots and other special characters will be treated as a single segment.

impl LogEvent

Log Namespace utility methods. These can only be used when an event has a valid schema definition set (which should be on every event in transforms and sinks).

pub fn message_path(&self) -> Option<&OwnedTargetPath>

Fetches the “message” path of the event. This is either from the “message” semantic meaning (Vector namespace) or from the message key set on the “Global Log Schema” (Legacy namespace).

pub fn timestamp_path(&self) -> Option<&OwnedTargetPath>

Fetches the “timestamp” path of the event. This is either from the “timestamp” semantic meaning (Vector namespace) or from the timestamp key set on the “Global Log Schema” (Legacy namespace).

pub fn host_path(&self) -> Option<&OwnedTargetPath>

Fetches the host path of the event. This is either from the “host” semantic meaning (Vector namespace) or from the host key set on the “Global Log Schema” (Legacy namespace).

pub fn source_type_path(&self) -> Option<&OwnedTargetPath>

Fetches the source_type path of the event. This is either from the source_type Vector metadata field (Vector namespace) or from the source_type key set on the “Global Log Schema” (Legacy namespace).

pub fn get_message(&self) -> Option<&Value>

Fetches the message of the event. This is either from the “message” semantic meaning (Vector namespace) or from the message key set on the “Global Log Schema” (Legacy namespace).

pub fn get_timestamp(&self) -> Option<&Value>

Fetches the timestamp of the event. This is either from the “timestamp” semantic meaning (Vector namespace) or from the timestamp key set on the “Global Log Schema” (Legacy namespace).

pub fn remove_timestamp(&mut self) -> Option<Value>

Removes the timestamp from the event. This is either from the “timestamp” semantic meaning (Vector namespace) or from the timestamp key set on the “Global Log Schema” (Legacy namespace).

pub fn get_host(&self) -> Option<&Value>

Fetches the host of the event. This is either from the “host” semantic meaning (Vector namespace) or from the host key set on the “Global Log Schema” (Legacy namespace).

pub fn get_source_type(&self) -> Option<&Value>

Fetches the source_type of the event. This is either from the source_type Vector metadata field (Vector namespace) or from the source_type key set on the “Global Log Schema” (Legacy namespace).

Trait Implementations

impl AsMut<LogEvent> for TraceEvent

fn as_mut(&mut self) -> &mut LogEvent

Converts this type into a mutable reference of the (usually inferred) input type.

impl AsRef<LogEvent> for TraceEvent

fn as_ref(&self) -> &LogEvent

Converts this type into a shared reference of the (usually inferred) input type.

impl ByteSizeOf for LogEvent

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 LogEvent

fn clone(&self) -> LogEvent

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for LogEvent

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

Formats the value using the given formatter.

impl Default for LogEvent

fn default() -> LogEvent

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for LogEvent

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl EstimatedJsonEncodedSizeOf for LogEvent

fn estimated_json_encoded_size_of(&self) -> JsonSize

impl EventContainer for LogEvent

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) -> <LogEvent as EventContainer>::IntoIter

Turn this container into an iterator over Event.

impl EventDataEq for LogEvent

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

impl<K, V> Extend<(K, V)> for LogEvent

where K: AsRef<str>, V: Into<Value>,

fn extend<I>(&mut self, iter: I)

where I: IntoIterator<Item = (K, V)>,

Extends a collection with the contents of an iterator.

fn extend_one(&mut self, item: A)

🔬This is a nightly-only experimental API. (extend_one)

Extends a collection with exactly one element.

fn extend_reserve(&mut self, additional: usize)

🔬This is a nightly-only experimental API. (extend_one)

Reserves capacity in a collection for the given number of additional elements.

impl Finalizable for LogEvent

fn take_finalizers(&mut self) -> EventFinalizers

Consumes the finalizers of this object.

impl From<&Event<'_>> for LogEvent

fn from(event: &Event<'_>) -> LogEvent

Converts to this type from the input type.

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

fn from(log: &'a LogEvent) -> EventRef<'a>

Converts to this type from the input type.

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

fn from(log: &'a mut LogEvent) -> EventMutRef<'a>

Converts to this type from the input type.

impl From<BTreeMap<KeyString, Value>> for LogEvent

fn from(map: BTreeMap<KeyString, Value>) -> LogEvent

Converts to this type from the input type.

impl From<HashMap<KeyString, Value>> for LogEvent

fn from(map: HashMap<KeyString, Value>) -> LogEvent

Converts to this type from the input type.

impl From<Log> for LogEvent

fn from(log: Log) -> LogEvent

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

fn from(log: LogEvent) -> EventArray

Converts to this type from the input type.

impl From<LogEvent> for Log

fn from(log_event: LogEvent) -> Log

Converts to this type from the input type.

impl From<LogEvent> for TraceEvent

fn from(log: LogEvent) -> TraceEvent

Converts to this type from the input type.

impl From<LogEvent> for WithMetadata<Log>

fn from(log_event: LogEvent) -> WithMetadata<Log>

Converts to this type from the input type.

impl From<Value> for LogEvent

fn from(value: Value) -> LogEvent

Converts to this type from the input type.

impl<K, V> FromIterator<(K, V)> for LogEvent

where K: AsRef<str>, V: Into<Value>,

fn from_iter<T>(iter: T) -> LogEvent

where T: IntoIterator<Item = (K, V)>,

Creates a value from an iterator.

impl FromLua for LogEvent

fn from_lua(lua_value: Value, lua: &Lua) -> Result<LogEvent, Error>

Performs the conversion.

impl GetEventCountTags for LogEvent

fn get_tags(&self) -> TaggedEventsSent

impl IntoLua for LogEvent

fn into_lua(self, lua: &Lua) -> Result<Value, Error>

Performs the conversion.

impl MaybeAsLogMut for LogEvent

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

impl PartialEq for LogEvent

fn eq(&self, other: &LogEvent) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for LogEvent

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 TryFrom<Value> for LogEvent

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

The type returned in the event of a conversion error.

fn try_from(map: Value) -> Result<LogEvent, <LogEvent as TryFrom<Value>>::Error>

Performs the conversion.

impl TryInto<Value> for LogEvent

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

The type returned in the event of a conversion error.

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

Performs the conversion.

impl Visit for LogEvent

Note that tracing::field::Field containing dots and other special characters will be treated as a single segment.

fn record_str(&mut self, field: &Field, value: &str)

Visit a string value.

fn record_debug(&mut self, field: &Field, value: &dyn Debug)

Visit a value implementing fmt::Debug.

fn record_i64(&mut self, field: &Field, value: i64)

Visit a signed 64-bit integer value.

fn record_u64(&mut self, field: &Field, value: u64)

Visit an unsigned 64-bit integer value.

fn record_bool(&mut self, field: &Field, value: bool)

Visit a boolean value.

fn record_f64(&mut self, field: &Field, value: f64)

Visit a double-precision floating point value.

fn record_i128(&mut self, field: &Field, value: i128)

Visit a signed 128-bit integer value.

fn record_u128(&mut self, field: &Field, value: u128)

Visit an unsigned 128-bit integer value.

fn record_error(&mut self, field: &Field, value: &(dyn Error + 'static))

Records a type implementing Error.

impl StructuralPartialEq for LogEvent