Struct vector_core::schema::Definition

pub struct Definition { /* private fields */ }

The definition of a schema.

This struct contains all the information needed to inspect the schema of an event emitted by a source/transform.

Implementations

impl Definition

pub fn any() -> Self

The most general possible definition. The Kind is any, and all log_namespaces are enabled.

pub fn new_with_default_metadata( event_kind: Kind, log_namespaces: impl Into<BTreeSet<LogNamespace>>, ) -> Self

Creates a new definition that is of the event kind specified, and an empty object for metadata. There are no meanings. The log_namespaces are used to list the possible namespaces the schema is for.

pub fn new( event_kind: Kind, metadata_kind: Kind, log_namespaces: impl Into<BTreeSet<LogNamespace>>, ) -> Self

Creates a new definition, specifying both the event and metadata kind. There are no meanings. The log_namespaces are used to list the possible namespaces the schema is for.

pub fn default_legacy_namespace() -> Self

An object with any fields, and the Legacy namespace. This is the default schema for a source that does not explicitly provide one yet.

pub fn empty_legacy_namespace() -> Self

An object with no fields, and the Legacy namespace. This is what most sources use for the legacy namespace.

pub fn default_for_namespace(log_namespaces: &BTreeSet<LogNamespace>) -> Self

Returns the source schema for a source that produce the listed log namespaces, but an explicit schema was not provided.

pub fn log_namespaces(&self) -> &BTreeSet<LogNamespace>

The set of possible log namespaces that events can use. When merged, this is the union of all inputs.

pub fn with_standard_vector_source_metadata(self) -> Self

Adds the source_type and ingest_timestamp metadata fields, which are added to every Vector source. This function should be called in the same order as the values are actually inserted into the event.

pub fn with_source_metadata( self, source_name: &str, legacy_path: Option<LegacyKey<OwnedValuePath>>, vector_path: &OwnedValuePath, kind: Kind, meaning: Option<&str>, ) -> Self

This should be used wherever LogNamespace::insert_source_metadata is used to insert metadata. This automatically detects which log namespaces are used, and also automatically determines if there are possible conflicts from existing field names (usually from the selected decoder). This function should be called in the same order as the values are actually inserted into the event.

pub fn with_vector_metadata( self, legacy_path: Option<&OwnedValuePath>, vector_path: &OwnedValuePath, kind: Kind, meaning: Option<&str>, ) -> Self

This should be used wherever LogNamespace::insert_vector_metadata is used to insert metadata. This automatically detects which log namespaces are used, and also automatically determines if there are possible conflicts from existing field names (usually from the selected decoder). This function should be called in the same order as the values are actually inserted into the event.

pub fn with_field( self, target_path: &OwnedTargetPath, kind: Kind, meaning: Option<&str>, ) -> Self

Add type information for an event or metadata field. A non-root required field means the root type must be an object, so the type will be automatically restricted to an object.

Panics

• If the path is not root, and the definition does not allow the type to be an object.

pub fn with_event_field( self, path: &OwnedValuePath, kind: Kind, meaning: Option<&str>, ) -> Self

Add type information for an event field. A non-root required field means the root type must be an object, so the type will be automatically restricted to an object.

Panics

• If the path is not root, and the definition does not allow the type to be an object.
• Provided path has one or more coalesced segments (e.g. .(foo | bar)).

pub fn try_with_field( self, path: &OwnedValuePath, kind: Kind, meaning: Option<&str>, ) -> Self

Add type information for an event field. This inserts type information similar to LogEvent::try_insert.

pub fn with_metadata_field( self, path: &OwnedValuePath, kind: Kind, meaning: Option<&str>, ) -> Self

Add type information for an event field. A non-root required field means the root type must be an object, so the type will be automatically restricted to an object.

Panics

• If the path is not root, and the definition does not allow the type to be an object
• Provided path has one or more coalesced segments (e.g. .(foo | bar)).

pub fn optional_field( self, path: &OwnedValuePath, kind: Kind, meaning: Option<&str>, ) -> Self

Add type information for an optional event field.

Panics

See Definition::require_field.

pub fn with_meaning(self, target_path: OwnedTargetPath, meaning: &str) -> Self

Register a semantic meaning for the definition.

Panics

This method panics if the provided path points to an unknown location in the collection.

pub fn add_meaning(&mut self, target_path: OwnedTargetPath, meaning: &str)

Adds the meaning pointing to the given path to our list of meanings.

Panics

This method panics if the provided path points to an unknown location in the collection.

pub fn try_with_meaning( &mut self, target_path: OwnedTargetPath, meaning: &str, ) -> Result<(), &'static str>

Register a semantic meaning for the definition.

Errors

Returns an error if the provided path points to an unknown location in the collection.

pub fn unknown_fields(self, unknown: impl Into<Kind>) -> Self

Set the kind for all unknown fields.

pub fn merge(self, other: Self) -> Self

Merge other definition into self.

This just takes the union of both definitions.

pub fn combine_log_namespaces( log_namespaces: &BTreeSet<LogNamespace>, legacy: Self, vector: Self, ) -> Self

If the schema definition depends on the LogNamespace, this combines the individual definitions for each LogNamespace.

pub fn meaning_path(&self, meaning: &str) -> Option<&OwnedTargetPath>

Returns an OwnedTargetPath into an event, based on the provided meaning, if the meaning exists.

pub fn invalid_meaning( &self, meaning: &str, ) -> Option<&BTreeSet<OwnedTargetPath>>

pub fn meanings(&self) -> impl Iterator<Item = (&String, &OwnedTargetPath)>

pub fn add_meanings<'a>( &'a mut self, meanings: impl Iterator<Item = (&'a String, &'a OwnedTargetPath)>, )

Adds the meanings provided by an iterator over the given meanings.

Panics

This method panics if the provided path from any of the incoming meanings point to an unknown location in the collection.

pub fn event_kind(&self) -> &Kind

pub fn event_kind_mut(&mut self) -> &mut Kind

pub fn metadata_kind(&self) -> &Kind

pub fn kind_at<'a>(&self, target_path: impl TargetPath<'a>) -> Kind

Trait Implementations

impl Clone for Definition

fn clone(&self) -> Definition

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Definition

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

Formats the value using the given formatter.

impl PartialEq for Definition

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

fn partial_cmp(&self, other: &Definition) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

This method tests less than (for self and other) and is used by the < operator.

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

This method tests less than or equal to (for self and other) and is used by the <= operator.

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

This method tests greater than (for self and other) and is used by the > operator.

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

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl StructuralPartialEq for Definition