vrl 0.32.0

Vector Remap Language
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116

use std::fmt::Debug;

use super::{Matcher, Run};
use crate::datadog::search::{Comparison, ComparisonValue, Field};
use crate::path::PathParseError;
use dyn_clone::{DynClone, clone_trait_object};

/// A `Filter` is a generic type that contains methods that are invoked by the `build_filter`
/// function. Each method returns a heap-allocated `Matcher<V>` (typically a closure) containing
/// logic to determine whether the value matches the filter. A filter is intended to be side-effect
/// free and idempotent, and so only receives an immutable reference to self.
pub trait Filter<V: Debug + Send + Sync + Clone + 'static>: DynClone {
    /// Determine whether a field value exists.
    ///
    /// # Errors
    ///
    /// Will return `Err` if the query contains an invalid path.
    fn exists(&self, field: Field) -> Result<Box<dyn Matcher<V>>, PathParseError>;

    /// Determine whether a field value equals `to_match`.
    ///
    /// # Errors
    ///
    /// Will return `Err` if the query contains an invalid path.
    fn equals(&self, field: Field, to_match: &str) -> Result<Box<dyn Matcher<V>>, PathParseError>;

    /// Determine whether a value starts with a prefix.
    ///
    /// # Errors
    /// Will return `Err` if the query contains an invalid path.
    fn prefix(&self, field: Field, prefix: &str) -> Result<Box<dyn Matcher<V>>, PathParseError>;

    /// Determine whether a value matches a wildcard.
    ///
    /// # Errors
    ///
    /// Will return `Err` if the query contains an invalid path.
    fn wildcard(&self, field: Field, wildcard: &str)
    -> Result<Box<dyn Matcher<V>>, PathParseError>;

    /// Compare a field value against `comparison_value`, using one of the `comparator` operators.
    ///
    /// # Errors
    ///
    /// Will return `Err` if the query contains an invalid path.
    fn compare(
        &self,
        field: Field,
        comparator: Comparison,
        comparison_value: ComparisonValue,
    ) -> Result<Box<dyn Matcher<V>>, PathParseError>;

    /// Determine whether a field value falls within a range. By default, this will use
    /// `self.compare` on both the lower and upper bound.
    ///
    /// # Errors
    ///
    /// Will return `Err` if the query contains an invalid path.
    fn range(
        &self,
        field: Field,
        lower: ComparisonValue,
        lower_inclusive: bool,
        upper: ComparisonValue,
        upper_inclusive: bool,
    ) -> Result<Box<dyn Matcher<V>>, PathParseError> {
        match (&lower, &upper) {
            // If both bounds are wildcards, just check that the field exists to catch the
            // special case for "tags".
            (ComparisonValue::Unbounded, ComparisonValue::Unbounded) => self.exists(field),
            // Unbounded lower.
            (ComparisonValue::Unbounded, _) => {
                let op = if upper_inclusive {
                    Comparison::Lte
                } else {
                    Comparison::Lt
                };

                self.compare(field, op, upper)
            }
            // Unbounded upper.
            (_, ComparisonValue::Unbounded) => {
                let op = if lower_inclusive {
                    Comparison::Gte
                } else {
                    Comparison::Gt
                };

                self.compare(field, op, lower)
            }
            // Definitive range.
            _ => {
                let lower_op = if lower_inclusive {
                    Comparison::Gte
                } else {
                    Comparison::Gt
                };

                let upper_op = if upper_inclusive {
                    Comparison::Lte
                } else {
                    Comparison::Lt
                };

                let lower_func = self.compare(field.clone(), lower_op, lower)?;
                let upper_func = self.compare(field, upper_op, upper)?;

                Ok(Run::boxed(move |value| {
                    lower_func.run(value) && upper_func.run(value)
                }))
            }
        }
    }
}

clone_trait_object!(<V>Filter<V>);