Skip to content

FilteredEvent Trigger Operators#

This topic lists the available operators for use with the FilteredEvent trigger.

Operators

You can use the following operators to filter events.

Logical operators#

  • _and: Matches when all conditions are met

This operator requires all filters in the array to be true to include an event.

{"_and": [
  { ... filterA },
  { ... filterB }
]}
  • _or: Matches when at least one condition is met

This operator returns events that match any of the given filters.

{"_or": [
  { ... filterA },
  { ... filterB }
]}
  • _not: Excludes results that match the given filter

This operator inverts the condition, returning events that don't match the specified filter.

{"_not": {... filterA} }
  • _any: Matches any event (useful for wildcard filtering)

This operator removes all filtering and returns all events.

{  "_any": "" }

Comparison operators#

  • _lt, _gt, _lte, and _gte: Compare numerical values

These operators filter events based on less than (_lt), greater than (_gt), less than or equal (_lte), or greater than or equal (_gte) conditions.

{ "_lt": { "foo" : 42 } }
  • _eq and _is: Matches an exact value

_eq is an alias for _is. Both check for exact matches.

{ "_eq": { "foo": 42 } }

{ "_eq": { "foo": "LOW" } }

Also works with arrays:

{ "_eq": { "tags": ["foo", "bar"] } }

String operators#

  • _startsWith and _endsWith: Matches strings that begin or end with a specific sequence of characters

These operators filter events based on whether a string starts with or ends with a given value.

{ "_startsWith": { "foo": "LOW" } }
  • _like: Matches a string using wildcards (*)

This operator performs pattern matching using wildcards (*).

{ "_like": { "foo": "*ice" } }

{ "_like": { "foo": "ali*" } }

{ "_like": { "foo": "*lce*" } }

Range and inclusion operators#

  • _between: Matches values within a range

This operator returns events where a numeric field falls within a specified range.

{ "_between": { "_field": "foo", "_from": 0, "_to": 2 } }

Only works when foo is a number.

  • _in: Matches when a value exists in an array

This operator checks if a field’s value is one of the values in a predefined list.

Works with numbers:

{ "_in": { "_field": "foo", "_values": [1, 42] } }

Works with strings:

{ "_in": { "_field": "tags", "_values": ["foo", "bar"] } }

Existence and content operators#

  • _contains: Checks if a field contains a specific value

This operator searches within strings or arrays of strings.

{ "_contains": { "foo": "LOW" } }

Deprecation

The _contains operator is deprecated. Use _eq to search for exact values in arrays or _like to search for substrings.

  • _has: Checks if a field is present

This operator filters events that contain a specific field.

{ "_has": "foo" }
  • _empty: Checks if a field is empty

This operator filters events where a field is empty (contains "", an empty array [], or null).

{ "_empty": "foo" }

To check if a field doesn't exist, use:

{ "_not": {"_has": "foo"} }
  • _arrayMatch: Checks if any element within an array field satisfies a specified condition
{
    "_arrayMatch": {
        "_field": "foo",
        "_filter": {
            "_and": [
                {
                    "_eq": {
                        "name": "bar"
                    }
                },
                {
                    "_eq": {
                        "value": "LOW"
                    }
                }
            ]
        }
    }
}

Next steps