Struct Grok

pub struct Grok { /* private fields */ }

The Grok struct is the main entry point into using this library.

Implementations

impl Grok

pub const fn empty() -> Self

Creates a new Grok instance with no patterns.

pub fn with_default_patterns() -> Self

Creates a new Grok instance and loads all the default patterns.

For more information, see the patterns module.

pub fn add_pattern<S: Into<String>>(&mut self, name: S, pattern: S)

Adds a custom grok pattern.

A grok pattern is a standard regular expression string with grok pattern placeholders embedded in it.

The grok pattern placeholders are of the form %{name:alias:extract=definition}, where name is the name of the pattern, alias is the alias of the pattern, extract is the extract of the pattern, and definition is the definition of the pattern.

• name is the name of the pattern and is required. It may contain any alphanumeric character, or _.
• alias is the alias of the pattern and is optional. It may contain any alphanumeric character, or any of _-[].. If extract is provided, alias may be empty.
• extract is the extract of the pattern and is optional. It may contain any alphanumeric character, or any of _-[]..
• definition is the definition of the pattern and is optional. It may contain any character other than { or }.

A literal % character may appear in a grok pattern as long as it is not followed by {. You can surround the percent with grouped parentheses (%){..}, a non-capturing group (?:%){..}, or use the \x25 escape sequence, ie: \x25{..}.

pub fn compile( &self, pattern: &str, with_alias_only: bool, ) -> Result<Pattern, Error>

Compiles the given pattern, making it ready for matching.

Specify with_alias_only to only include the aliases in the matches rather that all named patterns. This may result in a more efficient compiled pattern.

Trait Implementations

impl Debug for Grok

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

Formats the value using the given formatter.

impl Default for Grok

The Default implementation for Grok whuich will load the default patterns.

fn default() -> Grok

Returns the “default value” for a type.

impl<S: Into<String>, const N: usize> From<[(S, S); N]> for Grok

Allows to construct Grok with an array of patterns directly.

Example:

let mut grok = Grok::from([("USERNAME", r"[a-zA-Z0-9._-]+")]);

fn from(arr: [(S, S); N]) -> Self

Converts to this type from the input type.

impl<S: Into<String>> FromIterator<(S, S)> for Grok

Allows to initialize Grok with an iterator of patterns.

Example:

let patterns = [("USERNAME", r"[a-zA-Z0-9._-]+")];
let mut grok = Grok::from_iter(patterns.into_iter());

fn from_iter<I: IntoIterator<Item = (S, S)>>(iter: I) -> Self

Creates a value from an iterator.