VRL function reference

Here you’ll find a comprehensive list of all built-in VRL functions. Functions are categorized by their purpose and sorted alphabetically for easy discovery. To use these functions in Vector, see the documentation on function call expressions and Vector’s remap transform.

Array functions

append

infallible

Appends each item in the items array to the end of the value array.

Function spec

append(value: <array>, items: <array>)

:: <array>

required optional <types | ...>

Argument	Type	Description	Default	Required?
value	array	The initial array		yes
items	array	The items to append		yes

Examples

Append to an array

Source

append([1, 2], [3, 4])

Return

[1,2,3,4]

chunks

fallible

Chunks value into slices of length chunk_size bytes

Function spec

chunks(value: <array | string>, chunk_size: <integer>)

:: <array> , <error>

required optional <types | ...>

Argument	Type	Description	Default	Required?
value	array string	The array of bytes to split.		yes
chunk_size	integer	The desired length of each chunk in bytes. This may be constrained by the host platform architecture.		yes

Errors

The chunks function is fallible, which means that error handling is required for these errors:

chunk_size must be at least 1 byte

chunk_size is too large

Examples

Split a string into chunks

Source

chunks("abcdefgh", 4)

Return

["abcd","efgh"]

Chunks do not respect unicode code point boundaries

Source

chunks("ab你好", 4)

Return

["ab�","�好"]

push

infallible

Adds the item to the end of the value array.

Function spec

push(value: <array>, item: <any>)

:: <array>

required optional <types | ...>

Argument	Type	Description	Default	Required?
value	array	The target array.		yes
item	any	The item to push.		yes

Examples

Push an item onto an array

Source

push([1, 2], 3)

Return

[1,2,3]

Codec functions

decode_base16

fallible

Decodes the value (a Base16 string) into its original string.

Function spec

decode_base16(value: <string>)

:: <string> , <error>

required optional <types | ...>

Argument	Type	Description	Default	Required?
value	string	The Base16 data to decode.		yes

Errors

The decode_base16 function is fallible, which means that error handling is required for these errors:

value isn’t a valid encoded Base16 string.

Examples

Decode Base16 data

Source

decode_base16!("796f752068617665207375636365737366756c6c79206465636f646564206d65")

Return

you have successfully decoded me

decode_base64

fallible

Decodes the value (a Base64 string) into its original string.

Function spec

decode_base64(value: <string>, [charset: <string>])

:: <string> , <error>

required optional <types | ...>

Argument	Type	Description	Default	Required?
value	string	The Base64 data to decode.		yes
charset	string	The character set to use when decoding the data.	`standard`	no

Errors

The decode_base64 function is fallible, which means that error handling is required for these errors:

value isn’t a valid encoded Base64 string.

Examples

Decode Base64 data (default)

Source

decode_base64!("eW91IGhhdmUgc3VjY2Vzc2Z1bGx5IGRlY29kZWQgbWU=")

Return

you have successfully decoded me

Decode Base64 data (URL safe)

Source

decode_base64!("eW91IGNhbid0IG1ha2UgeW91ciBoZWFydCBmZWVsIHNvbWV0aGluZyBpdCB3b24ndA==", charset: "url_safe")

Return

you can't make your heart feel something it won't

decode_gzip

fallible

Decodes the value (a Gzip string) into its original string.

Function spec

decode_gzip(value: <string>)

:: <string> , <error>

required optional <types | ...>

Argument	Type	Description	Default	Required?
value	string	The Gzip data to decode.		yes

Errors

The decode_gzip function is fallible, which means that error handling is required for these errors:

value isn’t a valid encoded Gzip string.

Examples

Decode Gzip data

Source

encoded_text = decode_base64!("H4sIAHEAymMAA6vML1XISCxLVSguTU5OLS5OK83JqVRISU3OT0lNUchNBQD7BGDaIAAAAA==")
decode_gzip!(encoded_text)

Return

you have successfully decoded me

decode_mime_q

fallible

Replaces q-encoded or base64-encoded encoded-word substrings in the value with their original string.

Function spec

decode_mime_q(value: <string>)

:: <string> , <error>

required optional <types | ...>

Argument	Type	Description	Default	Required?
value	string	The string with encoded-words to decode.		yes

Errors

The decode_mime_q function is fallible, which means that error handling is required for these errors:

value has invalid encoded encoded-word string.

Examples

Decode single encoded-word

Source

decode_mime_q!("=?utf-8?b?SGVsbG8sIFdvcmxkIQ==?=")

Return

Hello, World!

Embedded

Source

decode_mime_q!("From: =?utf-8?b?SGVsbG8sIFdvcmxkIQ==?= <=?utf-8?q?hello=5Fworld=40example=2ecom?=>")

Return

From: Hello, World! <hello_world@example.com>

Without charset

Source

decode_mime_q!("?b?SGVsbG8sIFdvcmxkIQ==")

Return

Hello, World!

decode_percent

infallible

Decodes a percent-encoded value like a URL.

Function spec

decode_percent(value: <string>)

:: <string>

required optional <types | ...>

Argument	Type	Description	Default	Required?
value	string	The string to decode.		yes

Examples

Percent decode a value

Source

decode_percent("foo%20bar%3F")

Return

foo bar?

decode_zlib

fallible

Decodes the value (a Zlib string) into its original string.

Function spec

decode_zlib(value: <string>)

:: <string> , <error>

required optional <types | ...>

Argument	Type	Description	Default	Required?
value	string	The Zlib data to decode.		yes

Errors

The decode_zlib function is fallible, which means that error handling is required for these errors:

value isn’t a valid encoded Zlib string.

Examples

Decode Zlib data

Source

encoded_text = decode_base64!("eJwNy4ENwCAIBMCNXIlQ/KqplUSgCdvXAS41qPMHshCB2R1zJlWIVlR6UURX2+wx2YcuK3kAb9C1wd6dn7Fa+QH9gRxr")
decode_zlib!(encoded_text)

Return

you_have_successfully_decoded_me.congratulations.you_are_breathtaking.

decode_zstd

fallible

Decodes the value (a Zstandard string) into its original string.

Function spec

decode_zstd(value: <string>)

:: <string> , <error>

required optional <types | ...>

Argument	Type	Description	Default	Required?
value	string	The Zstandard data to decode.		yes

Errors

The decode_zstd function is fallible, which means that error handling is required for these errors:

value isn’t a valid encoded Zstd string.

Examples

Decode Zstd data

Source

encoded_text = decode_base64!("KLUv/QBY/QEAYsQOFKClbQBedqXsb96EWDax/f/F/z+gNU4ZTInaUeAj82KqPFjUzKqhcfDqAIsLvAsnY1bI/N2mHzDixRQA")
decode_zstd!(encoded_text)

Return

you_have_successfully_decoded_me.congratulations.you_are_breathtaking.

encode_base16

infallible

Encodes the value to Base16.

Function spec

encode_base16(value: <string>)

:: <string>

required optional <types | ...>

Argument	Type	Description	Default	Required?
value	string	The string to encode.		yes

Examples

Encode to Base16

Source

encode_base16("please encode me")

Return

706c6561736520656e636f6465206d65

encode_base64

infallible

Encodes the value to Base64.

Function spec

encode_base64(value: <string>, [padding: <boolean>, charset: <string>])

:: <string>

required optional <types | ...>

Argument	Type	Description	Default	Required?
value	string	The string to encode.		yes
padding	boolean	Whether the Base64 output is padded.	`true`	no
charset	string	The character set to use when encoding the data.	`standard`	no

Examples

Encode to Base64 (default)

Source

encode_base64("please encode me")

Return

cGxlYXNlIGVuY29kZSBtZQ==

Encode to Base64 (without padding)

Source

encode_base64("please encode me, no padding though", padding: false)

Return

cGxlYXNlIGVuY29kZSBtZSwgbm8gcGFkZGluZyB0aG91Z2g

Encode to Base64 (URL safe)

Source

encode_base64("please encode me, but safe for URLs", charset: "url_safe")

Return

cGxlYXNlIGVuY29kZSBtZSwgYnV0IHNhZmUgZm9yIFVSTHM=

encode_gzip

infallible

Encodes the value to Gzip.

Function spec

encode_gzip(value: <string>, [compression_level: <integer>])

:: <string>

required optional <types | ...>

Argument	Type	Description	Default	Required?
value	string	The string to encode.		yes
compression_level	integer	The default compression level.	`6`	no

Examples

Encode to Gzip

Source

encoded_text = encode_gzip("please encode me")
encode_base64(encoded_text)

Return

H4sIAAAAAAAA/yvISU0sTlVIzUvOT0lVyE0FAI4R4vcQAAAA

encode_json

infallible

Encodes the value to JSON.

Function spec

encode_json(value: <any>)

:: <string>

required optional <types | ...>

Argument	Type	Description	Default	Required?
value	any	The value to convert to a JSON string.		yes

Examples

Encode to JSON

Source

.payload = encode_json({"hello": "world"})

Return

{"hello":"world"}

encode_key_value

fallible

Encodes the value to in key/value format with customizable delimiters. Default delimiters match the logfmt format.

Function spec

encode_key_value(value: <object>, [fields_ordering: <array>, key_value_delimiter: <string>, field_delimiter: <string>, flatten_boolean: <boolean>])

:: <string> , <error>

required optional <types | ...>

Argument	Type	Description	Default	Required?
value	object	The value to convert to a string.		yes
fields_ordering	array	The ordering of fields to preserve. Any fields not in this list will appear unordered, after any ordered fields.		no
key_value_delimiter	string	The string that separates the key from the value.	`=`	no
field_delimiter	string	The string that separates each key/value pair.		no
flatten_boolean	boolean	Whether to encode key/value with a boolean value as a standalone key if `true` and nothing if `false`.		no

Notices

This function has special behavior that you should be aware of.

If fields_ordering is specified then the function is fallible else it is infallible.

Errors

The encode_key_value function is fallible, which means that error handling is required for these errors:

fields_ordering contains a non-string element

Examples

Encode with default delimiters (no ordering)

Source

encode_key_value({"ts": "2021-06-05T17:20:00Z", "msg": "This is a message", "lvl": "info"})

Return

lvl=info msg="This is a message" ts=2021-06-05T17:20:00Z

Encode with default delimiters (fields ordering)

Source

encode_key_value!({"ts": "2021-06-05T17:20:00Z", "msg": "This is a message", "lvl": "info", "log_id": 12345}, ["ts", "lvl", "msg"])

Return

ts=2021-06-05T17:20:00Z lvl=info msg="This is a message" log_id=12345

Encode with default delimiters (nested fields)

Source

encode_key_value({"agent": {"name": "vector"}, "log": {"file": {"path": "my.log"}}, "event": "log"})

Return

agent.name=vector event=log log.file.path=my.log

Encode with default delimiters (nested fields ordering)

Source

encode_key_value!({"agent": {"name": "vector"}, "log": {"file": {"path": "my.log"}}, "event": "log"}, ["event", "log.file.path", "agent.name"])

Return

event=log log.file.path=my.log agent.name=vector

Encode with custom delimiters (no ordering)

Source

encode_key_value(
	{"ts": "2021-06-05T17:20:00Z", "msg": "This is a message", "lvl": "info"},
	field_delimiter: ",",
	key_value_delimiter: ":"
)

Return

lvl:info,msg:"This is a message",ts:2021-06-05T17:20:00Z

Encode with custom delimiters and flatten boolean

Source

encode_key_value(
	{"ts": "2021-06-05T17:20:00Z", "msg": "This is a message", "lvl": "info", "beta": true, "dropped": false},
	field_delimiter: ",",
	key_value_delimiter: ":",
	flatten_boolean: true
)

Return

beta,lvl:info,msg:"This is a message",ts:2021-06-05T17:20:00Z

encode_logfmt

fallible

Encodes the value to logfmt.

Function spec

encode_logfmt(value: <object>, [fields_ordering: <array>])

:: <string> , <error>

required optional <types | ...>

Argument	Type	Description	Default	Required?
value	object	The value to convert to a logfmt string.		yes
fields_ordering	array	The ordering of fields to preserve. Any fields not in this list will appear unordered, after any ordered fields.		no

Notices

This function has special behavior that you should be aware of.

If fields_ordering is specified then the function is fallible else it is infallible.

Errors

The encode_logfmt function is fallible, which means that error handling is required for these errors:

fields_ordering contains a non-string element

Examples

Encode to logfmt (no ordering)

Source

encode_logfmt({"ts": "2021-06-05T17:20:00Z", "msg": "This is a message", "lvl": "info"})

Return

lvl=info msg="This is a message" ts=2021-06-05T17:20:00Z

Encode to logfmt (fields ordering)

Source

encode_logfmt!({"ts": "2021-06-05T17:20:00Z", "msg": "This is a message", "lvl": "info", "log_id": 12345}, ["ts", "lvl", "msg"])

Return

ts=2021-06-05T17:20:00Z lvl=info msg="This is a message" log_id=12345

Encode to logfmt (nested fields)

Source

encode_logfmt({"agent": {"name": "vector"}, "log": {"file": {"path": "my.log"}}, "event": "log"})

Return

agent.name=vector event=log log.file.path=my.log

Encode to logfmt (nested fields ordering)

Source

encode_logfmt!({"agent": {"name": "vector"}, "log": {"file": {"path": "my.log"}}, "event": "log"}, ["event", "log.file.path", "agent.name"])

Return

event=log log.file.path=my.log agent.name=vector

encode_percent

infallible

Encodes a value with percent encoding to safely be used in URLs.

Function spec

encode_percent(value: <string>, [ascii_set: <string>])

:: <string>

required optional <types | ...>

Argument	Type	Description	Default	Required?
value	string	The string to encode.		yes
ascii_set	string	The ascii set to use when encoding the data.	`NON_ALPHANUMERIC`	no

Examples

Percent encode all non-alphanumeric characters (default)

Source

encode_percent("foo bar?")

Return

foo%20bar%3F

Percent encode only control characters

Source

encode_percent("foo 	bar", ascii_set: "CONTROLS")

Return

foo %09bar

encode_zlib

infallible

Encodes the value to Zlib.

Function spec

encode_zlib(value: <string>, [compression_level: <integer>])

:: <string>

required optional <types | ...>

Argument	Type	Description	Default	Required?
value	string	The string to encode.		yes
compression_level	integer	The default compression level.	`6`	no

Examples

Encode to Zlib

Source

encoded_text = encode_zlib("please encode me")
encode_base64(encoded_text)

Return

eJwryElNLE5VSM1Lzk9JVchNBQA0RQX7

encode_zstd

infallible

Encodes the value to Zstandard.

Function spec

encode_zstd(value: <string>, [compression_level: <integer>])

:: <string>

required optional <types | ...>

Argument	Type	Description	Default	Required?
value	string	The string to encode.		yes
compression_level	integer	The default compression level.	`3`	no

Examples

Encode to Zstd

Source

encoded_text = encode_zstd("please encode me")
encode_base64(encoded_text)

Return

KLUv/QBYgQAAcGxlYXNlIGVuY29kZSBtZQ==

Coerce functions

to_bool

fallible

Coerces the value into a boolean.

Function spec

to_bool(value: <boolean | integer | float | null | string>)

:: <boolean> , <error>

required optional <types | ...>

Argument	Type	Description	Default	Required?
value	boolean integer float null string	The value to convert to a Boolean.		yes

Errors

The to_bool function is fallible, which means that error handling is required for these errors:

value isn’t a supported boolean representation

Examples

Coerce to a Boolean (string)

Source

to_bool!("yes")

Return

true

Coerce to a Boolean (float)

Source

to_bool(0.0)

Coerce to a Boolean (int)

Source

to_bool(0)

Coerce to a Boolean (null)

Source

to_bool(null)

Coerce to a Boolean (Boolean)

Source

to_bool(true)

Return

true

to_float

fallible

Coerces the value into a float.

Function spec

to_float(value: <integer | float | boolean | string | timestamp>)

:: <float> , <error>

required optional <types | ...>

Argument	Type	Description	Default	Required?
value	integer float boolean string timestamp	The value to convert to a float. Must be convertible to a float, otherwise an error is raised.		yes

Errors

The to_float function is fallible, which means that error handling is required for these errors:

value isn’t a supported float representation

Examples

Coerce to a float

Source

to_float!("3.145")

Return

3.145

Coerce to a float (timestamp)

Source

to_float(t'2020-12-30T22:20:53.824727Z')

Return

1609366853.824727

to_int

fallible

Coerces the value into an integer.

Function spec

to_int(value: <integer | float | boolean | string | timestamp>)

:: <integer> , <error>

required optional <types | ...>

Argument	Type	Description	Default	Required?
value	integer float boolean string timestamp	The value to convert to an integer.		yes

Errors

The to_int function is fallible, which means that error handling is required for these errors:

value is a string but the text is not an integer

value is not a string, int, or timestamp

Examples

Coerce to an int (string)

Source

to_int!("2")

Return

Coerce to an int (timestamp)

Source

to_int(t'2020-12-30T22:20:53.824727Z')

Return

1609366853

to_regex

fallible

Coerces the value into a regex.

Function spec

to_regex(value: <string>)

:: <regex> , <error>

required optional <types | ...>

Argument	Type	Description	Default	Required?
value	string	The value to convert to a regex.		yes

Notices

This function has special behavior that you should be aware of.

Compiling a regular expression is an expensive operation and can limit Vector throughput. Don’t use this function unless you are absolutely sure there is no other way!

Errors

The to_regex function is fallible, which means that error handling is required for these errors:

value is not a string.

Examples

Coerce to a regex

Source

to_regex("^foo$") ?? r''

Return

^foo$

to_string

fallible

Coerces the value into a string.

Function spec

:: <string> , <error>

required optional <types | ...>

Argument	Type	Description	Default	Required?
value	integer float boolean string timestamp null	The value to convert to a string.		yes

Errors

The to_string function is fallible, which means that error handling is required for these errors:

value is not an integer, float, boolean, string, timestamp, or null

Examples

Coerce to a string (Boolean)

Source

to_string(true)

Return

true

Coerce to a string (int)

Source

to_string(52)

Return

Coerce to a string (float)

Source

to_string(52.2)

Return

52.2

to_timestamp

fallible

Coerces the value into a timestamp.

Function spec

to_timestamp(value: <string | float | integer | timestamp>, [unit: <string>])

:: <timestamp> , <error>

required optional <types | ...>

Argument	Type	Description	Default	Required?
value	string float integer timestamp	The value that is to be converted to a timestamp. If a string, must be a valid representation of a `timestamp` otherwise an `ArgumentError` will be raised.		yes
unit	string	The time unit.	`seconds`	no

Notices

This function has special behavior that you should be aware of.

There is the possibility of precision loss due to float arithmetic when coercing floats.

Errors

The to_timestamp function is fallible, which means that error handling is required for these errors:

When value is a string, it is not a valid timestamp format

When value is an int, it is not within the Unix timestamp range

When value is a float, it is not within the Unix timestamp range

Examples

Coerce a string to a timestamp

Source

to_timestamp!("2020-10-21T16:00:00Z")

Return

2020-10-21T16:00:00Z

Coerce a unix timestamp (integer) to a timestamp

Source

to_timestamp!(1675968923)

Return

2023-02-09T18:55:23Z

Coerce a unix timestamp (float) to a timestamp

Source

to_timestamp!(1675968923.567)

Return

2023-02-09T18:55:23.566999912Z

Coerce a unix timestamp, in milliseconds, to a timestamp

Source

to_timestamp!(1676478566639, unit: "milliseconds")

Return

2023-02-15T16:29:26.639Z

Coerce a unix timestamp, in nanoseconds, to a timestamp

Source

to_timestamp!(1675968923012312311, unit: "nanoseconds")

Return

2023-02-09T18:55:23.012312311Z

Convert functions

to_syslog_facility

fallible

Converts the value, a Syslog facility code, into its corresponding Syslog keyword. i.e. 0 into "kern", 1 into "user", etc.

Function spec

to_syslog_facility(value: <integer>)

:: <string> , <error>

required optional <types | ...>

Argument	Type	Description	Default	Required?
value	integer	The facility code.		yes

Errors

The to_syslog_facility function is fallible, which means that error handling is required for these errors:

value isn’t a valid Syslog facility code.

Examples

Coerce to a Syslog facility

Source

to_syslog_facility!(4)

Return

auth

to_syslog_level

fallible

Converts the value, a Syslog severity level, into its corresponding keyword, i.e. 0 into "emerg", 1 into "alert", etc.

Function spec

to_syslog_level(value: <integer>)

:: <string> , <error>

required optional <types | ...>

Argument	Type	Description	Default	Required?
value	integer	The severity level.		yes

Errors

The to_syslog_level function is fallible, which means that error handling is required for these errors:

value isn’t a valid Syslog severity level.

Examples

Coerce to a Syslog level

Source

to_syslog_level!(5)

Return

notice

to_syslog_severity

fallible

Converts the value, a Syslog log level keyword, into a Syslog integer severity level (0 to 7).

Function spec

to_syslog_severity(value: <string>)

:: <integer> , <error>

required optional <types | ...>

Argument	Type	Description	Default	Required?
value	string	The Syslog level keyword to convert.		yes

Errors

The to_syslog_severity function is fallible, which means that error handling is required for these errors:

value isn’t a valid Syslog level keyword

Examples

Coerce to Syslog severity

Source

to_syslog_severity!("alert")

Return

to_unix_timestamp

infallible

Converts the value timestamp into a Unix timestamp.

Returns the number of seconds since the Unix epoch by default, but milliseconds or nanoseconds can also be specified by unit.

Function spec

to_unix_timestamp(value: <timestamp>, [unit: <string>])

:: <integer>

required optional <types | ...>

Argument	Type	Description	Default	Required?
value	timestamp	The timestamp to convert to Unix.		yes
unit	string	The time unit.	`seconds`	no

Examples

Convert to a Unix timestamp (seconds)

Source

to_unix_timestamp(t'2021-01-01T00:00:00+00:00')

Return

1609459200

Convert to a Unix timestamp (milliseconds)

Source

to_unix_timestamp(t'2021-01-01T00:00:00Z', unit: "milliseconds")

Return

1609459200000

Convert to a Unix timestamp (nanoseconds)

Source

to_unix_timestamp(t'2021-01-01T00:00:00Z', unit: "nanoseconds")

Return

1609459200000000000

Debug functions

assert

fallible

Asserts the condition, which must be a Boolean expression. The program is aborted with message if the condition evaluates to false.

Function spec

assert(condition: <boolean>, [message: <string>])

:: <null> , <error>

required optional <types | ...>

Argument	Type	Description	Default	Required?
condition	boolean	The condition to check.		yes
message	string	An optional custom error message. If the equality assertion fails, `message` is appended to the default message prefix. See the examples below for a sample fully formed log message.		no

Notices

This function has special behavior that you should be aware of.

The assert function should be used in a standalone fashion and only when you want to abort the program. You should avoid it in logical expressions and other situations in which you want the program to continue if the condition evaluates to false.

Errors

The assert function is fallible, which means that error handling is required for these errors:

condition evaluates to false

Examples

Assertion (true)

Source

ok, err = assert("foo" == "foo", message: "\"foo\" must be \"foo\"!")

Return

true

Assertion (false)

Source

assert!("foo" == "bar", message: "\"foo\" must be \"foo\"!")

assert_eq

infallible

Asserts that two expressions, left and right, have the same value. The program is aborted with the message if they are unequal.

Function spec

assert_eq(left: <any>, right: <any>, [message: <string>])

:: <boolean>

required optional <types | ...>

Argument	Type	Description	Required?
left	any	The value to check for equality against `right`.	yes
right	any	The value to check for equality against `left`.	yes
message	string	An optional custom error message. If the equality assertion fails, `message` is appended to the default message prefix. See the examples below for a sample fully formed log message.	no

Notices

This function has special behavior that you should be aware of.

The assert_eq function should be used in a standalone fashion and only when you want to abort the program. You should avoid it in logical expressions and other situations in which you want the program to continue if the condition evaluates to false.

Examples

Successful assertion

Source

assert_eq!(1, 1)

Return

true

Unsuccessful assertion

Source

assert_eq!(127, [1, 2, 3])

Unsuccessful assertion with custom log message

Source

 assert_eq!(1, 0, message: "Unequal integers")

log

infallible

Logs the value to Vector’s stdout at the specified level.

Function spec

log(value: <any>, [level: <string>, rate_limit_secs: <integer>])

:: <null>

required optional <types | ...>

Argument	Type	Description	Default	Required?
value	any	The value to log.		yes
level	string	The log level.	`info`	no
rate_limit_secs	integer	Specifies that the log message is output no more than once per the given number of seconds. Use a value of `0` to turn rate limiting off.	`1`	no

Examples

Log a message

Source

log("Hello, World!", level: "info", rate_limit_secs: 60)

Log an error

Source

ts, err = to_int(.field)
if err != null {
	log(err, level: "error")
}

Enrichment functions

find_enrichment_table_records

infallible

Searches an enrichment table for rows that match the provided condition.

For file enrichment tables this condition needs to be a VRL object in which the key-value pairs indicate a field to search mapped to a value to search in that field. This function returns the rows that match the provided condition(s). All fields need to match for rows to be returned; if any fields don’t match, no rows are returned.

There are currently two forms of search criteria:

Exact match search. The given field must match the value exactly. Case sensitivity can be specified using the case_sensitive argument. An exact match search can use an index directly into the dataset, which should make this search fairly “cheap” from a performance perspective.
Date range search. The given field must be greater than or equal to the from date and less than or equal to the to date. Note that a date range search involves sequentially scanning through the rows that have been located via any exact match criteria. This can be an expensive operation if there are many rows returned by any exact match criteria. We recommend using date ranges as the only criteria when the enrichment data set is very small.

For geoip enrichment tables this condition needs to be a VRL object with a single key-value pair whose value needs to be a valid IP address. Example: {"ip": .ip }. If a return field is expected and without a value, null will be used. This table can return following fields:

ISP databases:
- autonomous_system_number
- autonomous_system_organization
- isp
- organization
City databases:
- city_name
- continent_code
- country_code
- country_name
- region_code
- region_name
- metro_code
- latitude
- longitude
- postal_code
- timezone
Connection-Type databases:
- connection_type

To use this function, you need to update your Vector configuration to include an enrichment_tables parameter.

Function spec

find_enrichment_table_records(table: <string>, condition: <object>, [select: <array>, case_sensitive: <boolean>])

:: <array>

required optional <types | ...>

Argument	Type	Description	Default	Required?
table	string	The enrichment table to search.		yes
condition	object	The condition to search on. Since the condition is used at boot time to create indices into the data, these conditions must be statically defined.		yes
select	array	A subset of fields from the enrichment table to return. If not specified, all fields are returned.		no
case_sensitive	boolean	Whether text fields need to match cases exactly.	`true`	no

Examples

Exact match

Source

find_enrichment_table_records!("test",
  {
	"surname": "smith",
  },
  case_sensitive: false)

Return

[{"firstname":"Bob","id":1,"surname":"Smith"},{"firstname":"Fred","id":2,"surname":"Smith"}]

Date range search

Source

find_enrichment_table_records!("test",
  {
	"surname": "Smith",
	"date_of_birth": {
	  "from": t'1985-01-01T00:00:00Z',
	  "to": t'1985-12-31T00:00:00Z'
	}
  })

Return

[{"firstname":"Bob","id":1,"surname":"Smith"},{"firstname":"Fred","id":2,"surname":"Smith"}]

get_enrichment_table_record

fallible

Searches an enrichment table for a row that matches the provided condition. A single row must be matched. If either no rows or more than one row is found, an error is returned.

There are currently two forms of search criteria:

Exact match search. The given field must match the value exactly. Case sensitivity can be specified using the case_sensitive argument. An exact match search can use an index directly into the dataset, which should make this search fairly “cheap” from a performance perspective.
Date range search. The given field must be greater than or equal to the from date and less than or equal to the to date. Note that a date range search involves sequentially scanning through the rows that have been located via any exact match criteria. This can be an expensive operation if there are many rows returned by any exact match criteria. We recommend using date ranges as the only criteria when the enrichment data set is very small.

ISP databases:
- autonomous_system_number
- autonomous_system_organization
- isp
- organization
City databases:
- city_name
- continent_code
- country_code
- country_name
- region_code
- region_name
- metro_code
- latitude
- longitude
- postal_code
- timezone
Connection-Type databases:
- connection_type

To use this function, you need to update your Vector configuration to include an enrichment_tables parameter.

Function spec

get_enrichment_table_record(table: <string>, condition: <object>, [select: <array>, case_sensitive: <boolean>])

:: <object> , <error>

required optional <types | ...>

Argument	Type	Description	Default	Required?
table	string	The enrichment table to search.		yes
condition	object	The condition to search on. Since the condition is used at boot time to create indices into the data, these conditions must be statically defined.		yes
select	array	A subset of fields from the enrichment table to return. If not specified, all fields are returned.		no
case_sensitive	boolean	Should text fields match case exactly.	`true`	no

Errors

The get_enrichment_table_record function is fallible, which means that error handling is required for these errors:

The row isn’t found

Multiple rows are found that match the condition

Examples

Exact match

Source

get_enrichment_table_record!("test",
  {
    "surname": "bob",
    "firstname": "John"
  },
  case_sensitive: false)

Return

{
  "firstname": "Bob",
  "id": 1,
  "surname": "Smith"
}

Date range search

Source

get_enrichment_table_record!("test",
  {
    "surname": "Smith",
    "date_of_birth": {
      "from": t'1985-01-01T00:00:00Z',
      "to": t'1985-12-31T00:00:00Z'
    }
  })

Return

{
  "firstname": "Bob",
  "id": 1,
  "surname": "Smith"
}

Enumerate functions

compact

infallible

Compacts the value by removing “empty” values, where emptiness is defined using the available parameters.

Function spec

compact(value: <array | object>, [recursive: <boolean>, null: <boolean>, string: <boolean>, object: <boolean>, array: <boolean>, nullish: <boolean>])

:: <array | object>

required optional <types | ...>

Argument	Type	Description	Default	Required?
value	array object	The object or array to compact.		yes
recursive	boolean	Whether the compaction be recursive.	`true`	no
null	boolean	Whether null should be treated as an empty value.	`true`	no
string	boolean	Whether an empty string should be treated as an empty value.	`true`	no
object	boolean	Whether an empty object should be treated as an empty value.	`true`	no
array	boolean	Whether an empty array should be treated as an empty value.	`true`	no
nullish	boolean	Tests whether the value is “nullish” as defined by the `is_nullish` function.		no

Examples

Compact an array

Source

compact(["foo", "bar", "", null, [], "buzz"], string: true, array: true, null: true)

Return

["foo","bar","buzz"]

Compact an object

Source

compact({"field1": 1, "field2": "", "field3": [], "field4": null}, string: true, array: true, null: true)

Return

{
  "field1": 1
}

filter

infallible

Filter elements from a collection.

This function currently does not support recursive iteration. If you have a need for recursive iteration using filter, then please let us know!

The function uses the “function closure syntax” to allow reading the key/value or index/value combination for each item in the collection.

The same scoping rules apply to closure blocks as they do for regular blocks, meaning, any variable defined in parent scopes are accessible, and mutations to those variables are preserved, but any new variables instantiated in the closure block are unavailable outside of the block.

Check out the examples below to learn about the closure syntax.

Function spec

filter(value: <array | object>)

:: <array | object>

required optional <types | ...>

Argument	Type	Description	Default	Required?
value	array object	The array or object to filter.		yes

Examples

Filter elements

Source

filter(array!(.tags)) -> |_index, value| {
    # keep any elements that aren't equal to "foo"
    value != "foo"
}

Return

["bar","baz"]

flatten

infallible

Flattens the value into a single-level representation.

Function spec

flatten(value: <array | object>, [separator: <string>])

:: <array | object>

required optional <types | ...>

Argument	Type	Description	Default	Required?
value	array object	The array or object to flatten.		yes
separator	string	The separator to be used to join nested keys	`.`	no

Examples

Flatten array

Source

flatten([1, [2, 3, 4], [5, [6, 7], 8], 9])

Return

[1,2,3,4,5,6,7,8,9]

Flatten object

Source

flatten({
	"parent1": {
		"child1": 1,
		"child2": 2
	},
	"parent2": {
		"child3": 3
	}
})

Return

{
  "parent1.child1": 1,
  "parent1.child2": 2,
  "parent2.child3": 3
}

for_each

infallible

Iterate over a collection.

This function currently does not support recursive iteration. If you have a need for recursive iteration using for_each, which can’t be solved using the map_keys or map_values enumeration functions (which do support recursion), then please let us know!

The function uses the “function closure syntax” to allow reading the key/value or index/value combination for each item in the collection.

Check out the examples below to learn about the closure syntax.

Function spec

for_each(value: <array | object>)

:: <null>

required optional <types | ...>

Argument	Type	Description	Default	Required?
value	array object	The array or object to iterate.		yes

Examples

Tally elements

Source

tally = {}
for_each(array!(.tags)) -> |_index, value| {
    # Get the current tally for the `value`, or
    # set to `0`.
    count = int(get!(tally, [value])) ?? 0

    # Increment the tally for the value by `1`.
    tally = set!(tally, [value], count + 1)
}

tally

Return

{
  "bar": 1,
  "baz": 1,
  "foo": 2
}

includes

infallible

Determines whether the value array includes the specified item.

Function spec

includes(value: <array>, item: <any>)

:: <boolean>

required optional <types | ...>

Argument	Type	Description	Default	Required?
value	array	The array.		yes
item	any	The item to check.		yes

Examples

Array includes

Source

includes(["apple", "orange", "banana"], "banana")

Return

true

keys

infallible

Returns the keys from the object passed into the function.

Function spec

keys(value: <object>)

:: <array>

required optional <types | ...>

Argument	Type	Description	Default	Required?
value	object	The object to extract keys from.		yes

Examples

Get keys from the object.

Source

keys({"key1": "val1", "key2": "val2"})

Return

["key1","key2"]

length

infallible

Returns the length of the value.

If value is an array, returns the number of elements.
If value is an object, returns the number of top-level keys.
If value is a string, returns the number of bytes in the string. If you want the number of characters, see strlen.

Function spec

length(value: <array | object | string>)

:: <integer>

required optional <types | ...>

Argument	Type	Description	Default	Required?
value	array object string	The array or object		yes

Examples

Length (object)

Source

length({
	"portland": "Trail Blazers",
	"seattle":  "Supersonics"
})

Return

Length (nested object)

Source

length({
	"home": {
		"city":  "Portland",
		"state": "Oregon"
	},
	"name": "Trail Blazers",
	"mascot": {
		"name": "Blaze the Trail Cat"
	}
})

Return

Length (array)

Source

length(["Trail Blazers", "Supersonics", "Grizzlies"])

Return

Length (string)

Source

length("The Planet of the Apes Musical")

Return

map_keys

infallible

Map the keys within an object.

If recursive is enabled, the function iterates into nested objects, using the following rules:

Iteration starts at the root.
For every nested object type:
- First return the key of the object type itself.
- Then recurse into the object, and loop back to item (1) in this list.
- Any mutation done on a nested object before recursing into it, are preserved.
For every nested array type:
- First return the key of the array type itself
- Then find all objects within the array, and apply item (2) to each individual object.

Practically speaking, the above rules mean that map_keys with recursive enabled will find all keys in the target, regardless of whether nested objects are nested inside arrays.

The function uses the “function closure syntax” to allow reading the key for each item in the object.

Check out the examples below to learn about the closure syntax.

Function spec

map_keys(value: <object>, [recursive: <boolean>])

:: <object>

required optional <types | ...>

Argument	Type	Description	Default	Required?
value	object	The object to iterate.		yes
recursive	boolean	Whether to recursively iterate the collection.		no

Examples

Upcase keys

Source

map_keys(.) -> |key| { upcase(key) }

Return

{
  "BAR": "bar",
  "FOO": "foo"
}

De-dot keys

Source

map_keys(., recursive: true) -> |key| { replace(key, ".", "_") }

Return

{
  "labels": {
    "app_kubernetes_io/name": "mysql"
  }
}

map_values

infallible

Map the values within a collection.

If recursive is enabled, the function iterates into nested collections, using the following rules:

Iteration starts at the root.
For every nested collection type:
- First return the collection type itself.
- Then recurse into the collection, and loop back to item (1) in the list
- Any mutation done on a collection before recursing into it, are preserved.

The function uses the “function closure syntax” to allow mutating the value for each item in the collection.

Check out the examples below to learn about the closure syntax.

Function spec

map_values(value: <array | object>, [recursive: <boolean>])

:: <array | object>

required optional <types | ...>

Argument	Type	Description	Default	Required?
value	array object	The object or array to iterate.		yes
recursive	boolean	Whether to recursively iterate the collection.		no

Examples

Upcase values

Source

map_values(.) -> |value| { upcase!(value) }

Return

{
  "bar": "BAR",
  "foo": "FOO"
}

match_array

infallible

Determines whether the elements in the value array matches the pattern - by default it checks at least one element matches, but can be set to determine if all the elements match.

Function spec

match_array(value: <array>, pattern: <regex>, [all: <boolean>])

:: <boolean>

required optional <types | ...>

Argument	Type	Description	Required?
value	array	The array.	yes
pattern	regex	The regular expression pattern to match against.	yes
all	boolean	Whether to match on all elements of `value`.	no

Examples

Match at least one element

Source

	match_array(["foobar", "bazqux"], r'foo')

Return

true

Match all elements

Source

	match_array(["foo", "foobar", "barfoo"], r'foo', all: true)

Return

true

No matches

Source

	match_array(["bazqux", "xyz"], r'foo')

Not all elements match

Source

	match_array(["foo", "foobar", "baz"], r'foo', all: true)

strlen

infallible

Returns the number of UTF-8 characters in value. This differs from length which would count the number of bytes of a string.

Note that this is the count of unicode scalar values which can sometimes differ from unicode code points.

Function spec

strlen(value: <string>)

:: <integer>

required optional <types | ...>

Argument	Type	Description	Default	Required?
value	string	The string		yes

Examples

strlen

Source

strlen("ñandú")

Return

unique

infallible

Returns unique values for an array.

The first occurrence of each element is kept.

Function spec

unique(value: <array>)

:: <array>

required optional <types | ...>

Argument	Type	Description	Default	Required?
value	array	The array to return unique elements from.		yes

Examples

Unique

Source

unique(["foo", "bar", "foo", "baz"])

Return

["foo","bar","baz"]

values

infallible

Returns the values from the object passed into the function.

Function spec

values(value: <object>)

:: <array>

required optional <types | ...>

Argument	Type	Description	Default	Required?
value	object	The object to extract values from.		yes

Examples

Get values from the object.

Source

values({"key1": "val1", "key2": "val2"})

Return

["val1","val2"]

Event functions

get_secret

infallible

Returns the value of the given secret from an event.

Function spec

get_secret(key: <string>)

:: <string>

required optional <types | ...>

Argument	Type	Description	Default	Required?
key	string	The name of the secret.		yes

Examples

Get the Datadog API key from the event metadata.

Source

get_secret("datadog_api_key")

Return

secret value

remove_secret

infallible

Removes a secret from an event.

Function spec

remove_secret(key: <string>)

:: <null>

required optional <types | ...>

Argument	Type	Description	Default	Required?
key	string	The name of the secret to remove.		yes

Examples

Removes the Datadog API key from the event.

Source

remove_secret("datadog_api_key")

set_secret

infallible

Sets the given secret in the event.

Function spec

set_secret(key: <string>, secret: <string>)

:: <null>

required optional <types | ...>

Argument	Type	Description	Default	Required?
key	string	The name of the secret.		yes
secret	string	The secret value.		yes

Examples

Set the Datadog API key to the given value.

Source

set_secret("datadog_api_key", "abc122")

Path functions

del

infallible

Removes the field specified by the static path from the target.

For dynamic path deletion, see the remove function.

Function spec

del(path: <path>, [compact: <boolean>])

:: <any>

required optional <types | ...>

Argument	Type	Description	Default	Required?
path	path	The path of the field to delete.		yes
compact	boolean	If compact is true, after deletion, if an empty object or array is left behind, it should be removed as well, cascading up to the root. This only applies to the path being deleted, and any parent paths.		no

Notices

This function has special behavior that you should be aware of.

The del function modifies the current event in place and returns the value of the deleted field.

Examples

Delete a field

Source

del(.field1)

Rename a field

Source

.new_field = del(.old_field)

exists

infallible

Checks whether the path exists for the target.

This function allows you to distinguish between a missing path, or a path with a null value, something a regular path lookup such as .foo would not allow, since that always returns null if the path doesn’t exist.

Function spec

exists(path: <path>)

:: <boolean>

required optional <types | ...>

Argument	Type	Description	Default	Required?
path	path	The path of the field to check.		yes

Examples

Exists (field)

Source

exists(.field)

Return

true

Exists (array element)

Source

exists(.array[2])

Return

true

get

fallible

Dynamically get the value of a given path.

When you know the path you want to look up, you should use static paths such as .foo.bar[1] to get the value of that path. However, when you don’t know the path names in advance, you can use this dynamic get function to get at the requested value.

Function spec

get(value: <object | array>, path: <array>)

:: <any> , <error>

required optional <types | ...>

Argument	Type	Description	Default	Required?
value	object array	The object or array to query.		yes
path	array	An array of path segments to look up the value for.		yes

Errors

The get function is fallible, which means that error handling is required for these errors:

path segment must be either “string” or “integer”

Examples

single-segment top-level field

Source

get!(value: { "foo": "bar" }, path: ["foo"])

Return

bar

multi-segment nested field

Source

get!(value: { "foo": { "bar": "baz" } }, path: ["foo", "bar"])

Return

baz

array indexing

Source

get!(value: ["foo", "bar", "baz"], path: [-2])

Return

bar

remove

fallible

Dynamically remove the value for a given path.

When you know the path you want to remove, you should use the del function and static paths such as del(.foo.bar[1]) to remove the value at that path. The del function returns the deleted value, and is more performant than this function. However, when you don’t know the path names in advance, you can use this dynamic remove function to remove the value at the provided path.

Function spec

remove(value: <object | array>, path: <array>, [compact: <boolean>])

:: <object | array> , <error>

required optional <types | ...>

Argument	Type	Description	Required?
value	object array	The object or array to remove data from.	yes
path	array	An array of path segments to remove the value at.	yes
compact	boolean	Whether — after deletion — empty objects or arrays should be removed.	no

Errors

The remove function is fallible, which means that error handling is required for these errors:

path segment must be either “string” or “integer”

Examples

single-segment top-level field

Source

remove!(value: { "foo": "bar" }, path: ["foo"])

multi-segment nested field

Source

remove!(value: { "foo": { "bar": "baz" } }, path: ["foo", "bar"])

Return

{
  "foo": {}
}

array indexing

Source

remove!(value: ["foo", "bar", "baz"], path: [-2])

Return

["foo","baz"]

compaction

Source

remove!(value: { "foo": { "bar": [42], "baz": true } }, path: ["foo", "bar", 0], compact: true)

Return

{
  "foo": {
    "baz": true
  }
}

set

fallible

Dynamically insert data into the path of a given object or array.

When you know the path you want to assign a value to, you should use static path assignments such as .foo.bar[1] = true for improved performance and readability. However, when you don’t know the path names in advance, you can use this dynamic insertion function to insert the data into the object or array.

Function spec

set(value: <object | array>, path: <array>, data: <any>)

:: <object | array> , <error>

required optional <types | ...>

Argument	Type	Description	Required?
value	object array	The object or array to insert data into.	yes
path	array	An array of path segments to insert the value to.	yes
data	any	The data to be inserted.	yes

Errors

The set function is fallible, which means that error handling is required for these errors:

path segment must be either “string” or “integer”

Examples

single-segment top-level field

Source

set!(value: { "foo": "bar" }, path: ["foo"], data: "baz")

Return

{
  "foo": "baz"
}

multi-segment nested field

Source

set!(value: { "foo": { "bar": "baz" } }, path: ["foo", "bar"], data: "qux")

Return

{
  "foo": {
    "bar": "qux"
  }
}

array

Source

set!(value: ["foo", "bar", "baz"], path: [-2], data: 42)

Return

["foo",42,"baz"]

Cryptography functions

decrypt

fallible

Decrypts a string with a symmetric encryption algorithm.

Supported Algorithms:

AES-256-CFB (key = 32 bytes, iv = 16 bytes)
AES-192-CFB (key = 24 bytes, iv = 16 bytes)
AES-128-CFB (key = 16 bytes, iv = 16 bytes)
AES-256-OFB (key = 32 bytes, iv = 16 bytes)
AES-192-OFB (key = 24 bytes, iv = 16 bytes)
AES-128-OFB (key = 16 bytes, iv = 16 bytes)
AES-256-CTR (key = 32 bytes, iv = 16 bytes)
AES-192-CTR (key = 24 bytes, iv = 16 bytes)
AES-128-CTR (key = 16 bytes, iv = 16 bytes)
AES-256-CBC-PKCS7 (key = 32 bytes, iv = 16 bytes)
AES-192-CBC-PKCS7 (key = 24 bytes, iv = 16 bytes)
AES-128-CBC-PKCS7 (key = 16 bytes, iv = 16 bytes)
AES-256-CBC-ANSIX923 (key = 32 bytes, iv = 16 bytes)
AES-192-CBC-ANSIX923 (key = 24 bytes, iv = 16 bytes)
AES-128-CBC-ANSIX923 (key = 16 bytes, iv = 16 bytes)
AES-256-CBC-ISO7816 (key = 32 bytes, iv = 16 bytes)
AES-192-CBC-ISO7816 (key = 24 bytes, iv = 16 bytes)
AES-128-CBC-ISO7816 (key = 16 bytes, iv = 16 bytes)
AES-256-CBC-ISO10126 (key = 32 bytes, iv = 16 bytes)
AES-192-CBC-ISO10126 (key = 24 bytes, iv = 16 bytes)
AES-128-CBC-ISO10126 (key = 16 bytes, iv = 16 bytes)

Function spec

decrypt(ciphertext: <string>, algorithm: <string>, key: <string>, iv: <string>)

:: <string> , <error>

required optional <types | ...>

Argument	Type	Description	Required?
ciphertext	string	The string to decrypt. The should be raw bytes (not encoded).	yes
algorithm	string	The algorithm to use.	yes
key	string	The key for decryption. The should be raw bytes of the key (not encoded). The length must match the algorithm requested.	yes
iv	string	The IV for decryption. The should be raw bytes of the IV (not encoded). The length must match the algorithm requested. A new IV should be generated for every message. You can use `random_bytes` to generate a cryptographically secure random value. The value should match the one used during encryption.	yes

Errors

The decrypt function is fallible, which means that error handling is required for these errors:

algorithm isn’t a supported algorithm

key length doesn’t match the key size required for the algorithm specified

iv length doesn’t match the iv size required for the algorithm specified

Examples

Decrypt value

Source

ciphertext = decode_base64!("5fLGcu1VHdzsPcGNDio7asLqE1P43QrVfPfmP4i4zOU=")
iv = decode_base64!("fVEIRkIiczCRWNxaarsyxA==")
key = "16_byte_keyxxxxx"
decrypt!(ciphertext, "AES-128-CBC-PKCS7", key, iv: iv)

Return

super_secret_message

encrypt

fallible

Encrypts a string with a symmetric encryption algorithm.

Supported Algorithms:

AES-256-CFB (key = 32 bytes, iv = 16 bytes)
AES-192-CFB (key = 24 bytes, iv = 16 bytes)
AES-128-CFB (key = 16 bytes, iv = 16 bytes)
AES-256-OFB (key = 32 bytes, iv = 16 bytes)
AES-192-OFB (key = 24 bytes, iv = 16 bytes)
AES-128-OFB (key = 16 bytes, iv = 16 bytes)
AES-256-CTR (key = 32 bytes, iv = 16 bytes)
AES-192-CTR (key = 24 bytes, iv = 16 bytes)
AES-128-CTR (key = 16 bytes, iv = 16 bytes)
AES-256-CBC-PKCS7 (key = 32 bytes, iv = 16 bytes)
AES-192-CBC-PKCS7 (key = 24 bytes, iv = 16 bytes)
AES-128-CBC-PKCS7 (key = 16 bytes, iv = 16 bytes)
AES-256-CBC-ANSIX923 (key = 32 bytes, iv = 16 bytes)
AES-192-CBC-ANSIX923 (key = 24 bytes, iv = 16 bytes)
AES-128-CBC-ANSIX923 (key = 16 bytes, iv = 16 bytes)
AES-256-CBC-ISO7816 (key = 32 bytes, iv = 16 bytes)
AES-192-CBC-ISO7816 (key = 24 bytes, iv = 16 bytes)
AES-128-CBC-ISO7816 (key = 16 bytes, iv = 16 bytes)
AES-256-CBC-ISO10126 (key = 32 bytes, iv = 16 bytes)
AES-192-CBC-ISO10126 (key = 24 bytes, iv = 16 bytes)
AES-128-CBC-ISO10126 (key = 16 bytes, iv = 16 bytes)

Function spec

encrypt(plaintext: <string>, algorithm: <string>, key: <string>, iv: <string>)

:: <string> , <error>

required optional <types | ...>

Argument	Type	Description	Required?
plaintext	string	The string to encrypt.	yes
algorithm	string	The algorithm to use.	yes
key	string	The key for encryption. The should be raw bytes of the key (not encoded). The length must match the algorithm requested.	yes
iv	string	The IV for encryption. The should be raw bytes of the IV (not encoded). The length must match the algorithm requested. A new IV should be generated for every message. You can use `random_bytes` to generate a cryptographically secure random value.	yes

Errors

The encrypt function is fallible, which means that error handling is required for these errors:

algorithm isn’t a supported algorithm

key length doesn’t match the key size required for the algorithm specified

iv length doesn’t match the iv size required for the algorithm specified

Examples

Encrypt value

Source

plaintext = "super secret message"
iv = "1234567890123456" # typically you would call random_bytes(16)
key = "16_byte_keyxxxxx"
encrypted_message = encrypt!(plaintext, "AES-128-CBC-PKCS7", key, iv: iv)
encode_base64(encrypted_message)

Return

GBw8Mu00v0Kc38+/PvsVtGgWuUJ+ZNLgF8Opy8ohIYE=

hmac

infallible

Calculates a HMAC of the value using the given key. The hashing algorithm used can be optionally specified.

For most use cases, the resulting bytestream should be encoded into a hex or base64 string using either encode_base16 or encode_base64.

This function is infallible if either the default algorithm value, or a recognized-valid compile-time algorithm string literal is used. Otherwise it is fallible.

Function spec

hmac(value: <string>, key: <string>, [algorithm: <string>])

:: <string>

required optional <types | ...>

Argument	Type	Description	Default	Required?
value	string	The string to calculate the HMAC for.		yes
key	string	The string to use as the cryptographic key.		yes
algorithm	string	The hashing algorithm to use.	`SHA-256`	no

Examples

Calculate message HMAC (defaults: SHA-256), encoding to a base64 string

Source

encode_base64(hmac("Hello there", "super-secret-key"))

Return

eLGE8YMviv85NPXgISRUZxstBNSU47JQdcXkUWcClmI=

Calculate message HMAC using SHA-224, encoding to a hex-encoded string

Source

encode_base16(hmac("Hello there", "super-secret-key", algorithm: "SHA-224"))

Return

42fccbc2b7d22a143b92f265a8046187558a94d11ddbb30622207e90

Calculate message HMAC using a variable hash algorithm

Source

.hash_algo = "SHA-256"
hmac_bytes, err = hmac("Hello there", "super-secret-key", algorithm: .hash_algo)
if err == null {
	.hmac = encode_base16(hmac_bytes)
}

Return

78b184f1832f8aff3934f5e0212454671b2d04d494e3b25075c5e45167029662

md5

infallible

Calculates an md5 hash of the value.

Function spec

md5(value: <string>)

:: <string>

required optional <types | ...>

Argument	Type	Description	Default	Required?
value	string	The string to calculate the hash for.		yes

Examples

Create md5 hash

Source

md5("foo")

Return

acbd18db4cc2f85cedef654fccc4a4d8

seahash

infallible

Calculates a Seahash hash of the value. Note: Due to limitations in the underlying VRL data types, this function converts the unsigned 64-bit integer seahash result to a signed 64-bit integer. Results higher than the signed 64-bit integer maximum value wrap around to negative values.

Function spec

seahash(value: <string>)

:: <integer>

required optional <types | ...>

Argument	Type	Description	Default	Required?
value	string	The string to calculate the hash for.		yes

Examples

Calculate seahash

Source

seahash("foobar")

Return

5348458858952426000

Calculate negative seahash

Source

seahash("bar")

Return

-2796170501982571500

sha1

infallible

Calculates a SHA-1 hash of the value.

Function spec

sha1(value: <string>)

:: <string>

required optional <types | ...>

Argument	Type	Description	Default	Required?
value	string	The string to calculate the hash for.		yes

Examples

Calculate sha1 hash

Source

sha1("foo")

Return

0beec7b5ea3f0fdbc95d0dd47f3c5bc275da8a33

sha2

infallible

Calculates a SHA-2 hash of the value.

Function spec

sha2(value: <string>, [variant: <string>])

:: <string>

required optional <types | ...>

Argument	Type	Description	Default	Required?
value	string	The string to calculate the hash for.		yes
variant	string	The variant of the algorithm to use.	`SHA-512/256`	no

Examples

Calculate sha2 hash

Source

sha2("foo", variant: "SHA-512/224")

Return

d68f258d37d670cfc1ec1001a0394784233f88f056994f9a7e5e99be

sha3

infallible

Calculates a SHA-3 hash of the value.

Function spec

sha3(value: <string>, [variant: <string>])

:: <string>

required optional <types | ...>

Argument	Type	Description	Default	Required?
value	string	The string to calculate the hash for.		yes
variant	string	The variant of the algorithm to use.	`SHA3-512`	no

Examples

Calculate sha3 hash

Source

sha3("foo", variant: "SHA3-224")

Return

f4f6779e153c391bbd29c95e72b0708e39d9166c7cea51d1f10ef58a

IP functions

ip_aton

fallible

Converts IPv4 address in numbers-and-dots notation into network-order bytes represented as an integer.

This behavior mimics inet_aton.

Function spec

ip_aton(value: <string>)

:: <integer> , <error>

required optional <types | ...>

Argument	Type	Description	Default	Required?
value	string	The IP address to convert to binary.		yes

Errors

The ip_aton function is fallible, which means that error handling is required for these errors:

value isn’t a valid IPv4 address

Examples

IPv4 to integer

Source

ip_aton!("1.2.3.4")

Return

16909060

ip_cidr_contains

fallible

Determines whether the ip is contained in the block referenced by the cidr.

Function spec

ip_cidr_contains(cidr: <string>, ip: <string>)

:: <boolean> , <error>

required optional <types | ...>

Argument	Type	Description	Default	Required?
cidr	string	The CIDR mask (v4 or v6).		yes
ip	string	The IP address (v4 or v6).		yes

Errors

The ip_cidr_contains function is fallible, which means that error handling is required for these errors:

cidr isn’t a valid CIDR

ip isn’t a valid IP address

Examples

IPv4 contains CIDR

Source

ip_cidr_contains!("192.168.0.0/16", "192.168.10.32")

Return

true

IPv6 contains CIDR

Source

ip_cidr_contains!("2001:4f8:4:ba::/64", "2001:4f8:4:ba:2e0:81ff:fe22:d1f1")

Return

true

ip_ntoa

fallible

Converts numeric representation of IPv4 address in network-order bytes to numbers-and-dots notation..

This behavior mimics inet_ntoa.

Function spec

ip_ntoa(value: <string>)

:: <string> , <error>

required optional <types | ...>

Argument	Type	Description	Default	Required?
value	string	The integer representation of an IPv4 address.		yes

Errors

The ip_ntoa function is fallible, which means that error handling is required for these errors:

value cannot fit in u32

Examples

Integer to IPv4

Source

ip_ntoa!(16909060)

Return

1.2.3.4

ip_ntop

fallible

Converts IPv4 and IPv6 addresses from binary to text form.

This behavior mimics inet_ntop.

Function spec

ip_ntop(value: <string>)

:: <string> , <error>

required optional <types | ...>

Argument	Type	Description	Default	Required?
value	string	The binary data to convert from. For IPv4 addresses, it must be 4 bytes (32 bits) long. For IPv6 addresses, it must be 16 bytes (128 bits) long.		yes

Notices

This function has special behavior that you should be aware of.

The binary data for this function is not easily printable. However, the results from functions such as decode_base64 or decode_percent can still be used correctly.

Errors

The ip_ntop function is fallible, which means that error handling is required for these errors:

value must be of length 4 or 16 bytes

Examples

Convert IPv4 address from bytes after decoding from Base64

Source

ip_ntop!(decode_base64!("wKgAAQ=="))

Return

192.168.0.1

Convert IPv6 address from bytes after decoding from Base64

Source

ip_ntop!(decode_base64!("IAENuIWjAAAAAIouA3BzNA=="))

Return

2001:db8:85a3::8a2e:370:7334

ip_pton

fallible

Converts IPv4 and IPv6 addresses from text to binary form.

The binary form of IPv4 addresses is 4 bytes (32 bits) long.
The binary form of IPv6 addresses is 16 bytes (128 bits) long.

This behavior mimics inet_pton.

Function spec

ip_pton(value: <string>)

:: <string> , <error>

required optional <types | ...>

Argument	Type	Description	Default	Required?
value	string	The IP address (v4 or v6) to convert to binary form.		yes

Notices

This function has special behavior that you should be aware of.

The binary data from this function is not easily printable. However, functions such as encode_base64 or encode_percent can still process it correctly.

Errors

The ip_pton function is fallible, which means that error handling is required for these errors:

value isn’t a valid IP (v4 or v6) address in text form

Examples

Convert IPv4 address to bytes and encode to Base64

Source

encode_base64(ip_pton!("192.168.0.1"))

Return

wKgAAQ==

Convert IPv6 address to bytes and encode to Base64

Source

encode_base64(ip_pton!("2001:db8:85a3::8a2e:370:7334"))

Return

IAENuIWjAAAAAIouA3BzNA==

ip_subnet

fallible

Extracts the subnet address from the ip using the supplied subnet.

Function spec

ip_subnet(ip: <string>, subnet: <string>)

:: <string> , <error>

required optional <types | ...>

Argument	Type	Description	Default	Required?
ip	string	The IP address (v4 or v6).		yes
subnet	string	The subnet to extract from the IP address. This can be either a prefix length like `/8` or a net mask like `255.255.0.0`. The net mask can be either an IPv4 or IPv6 address.		yes

Notices

This function has special behavior that you should be aware of.

Works with both IPv4 and IPv6 addresses. The IP version for the mask must be the same as the supplied address.

Errors

The ip_subnet function is fallible, which means that error handling is required for these errors:

ip isn’t a valid IP address

subnet isn’t a valid subnet.

Examples

IPv4 subnet

Source

ip_subnet!("192.168.10.32", "255.255.255.0")

Return

192.168.10.0

IPv6 subnet

Source

ip_subnet!("2404:6800:4003:c02::64", "/32")

Return

2404:6800::

ip_to_ipv6

fallible

Converts the ip to an IPv6 address.

Function spec

ip_to_ipv6(ip: <string>)

:: <string> , <error>

required optional <types | ...>

Argument	Type	Description	Default	Required?
ip	string	The IP address to convert to IPv6.		yes

Errors

The ip_to_ipv6 function is fallible, which means that error handling is required for these errors:

ip isn’t a valid IP address

Examples

IPv4 to IPv6

Source

ip_to_ipv6!("192.168.10.32")

Return

::ffff:192.168.10.32

ipv6_to_ipv4

fallible

Converts the ip to an IPv4 address. ip is returned unchanged if it’s already an IPv4 address. If ip is currently an IPv6 address then it needs to be IPv4 compatible, otherwise an error is thrown.

Function spec

ipv6_to_ipv4(ip: <string>)

:: <string> , <error>

required optional <types | ...>

Argument	Type	Description	Default	Required?
ip	string	The IPv4-mapped IPv6 address to convert.		yes

Errors

The ipv6_to_ipv4 function is fallible, which means that error handling is required for these errors:

ip isn’t a valid IP address

ip is an IPv6 address that isn’t compatible with IPv4

Examples

IPv6 to IPv4

Source

ipv6_to_ipv4!("::ffff:192.168.0.1")

Return

192.168.0.1

is_ipv4

infallible

Check if the string is a valid IPv4 address or not.

An [IPv4-mapped][https://datatracker.ietf.org/doc/html/rfc6890] or [IPv4-compatible][https://datatracker.ietf.org/doc/html/rfc6890] IPv6 address is not considered valid for the purpose of this function.

Function spec

is_ipv4(value: <string>)

:: <boolean>

required optional <types | ...>

Argument	Type	Description	Default	Required?
value	string	The IP address to check		yes

Examples

Valid IPv4 address

Source

is_ipv4("10.0.102.37")

Return

true

Valid IPv6 address

Source

is_ipv4("2001:0db8:85a3:0000:0000:8a2e:0370:7334")

Arbitrary string

Source

is_ipv4("foobar")

is_ipv6

infallible

Check if the string is a valid IPv6 address or not.

Function spec

is_ipv6(value: <string>)

:: <boolean>

required optional <types | ...>

Argument	Type	Description	Default	Required?
value	string	The IP address to check		yes

Examples

Valid IPv6 address

Source

is_ipv6("2001:0db8:85a3:0000:0000:8a2e:0370:7334")

Return

true

Valid IPv4 address

Source

is_ipv6("10.0.102.37")

Arbitrary string

Source

is_ipv6("foobar")

Number functions

abs

infallible

Computes the absolute value of value.

Function spec

abs(value: <integer | float>)

:: <integer | float>

required optional <types | ...>

Argument	Type	Description	Default	Required?
value	integer float	The number to calculate the absolute value.		yes

Examples

Computes the absolute value of the integer

Source

abs(-42)

Return

Computes the absolute value of the float

Source

abs(-42.2)

Return

42.2

ceil

infallible

Rounds the value up to the specified precision.

Function spec

ceil(value: <integer | float>, [precision: <integer>])

:: <integer | float>

required optional <types | ...>

Argument	Type	Description	Default	Required?
value	integer float	The number to round up.		yes
precision	integer	The number of decimal places to round to.		no

Examples

Round a number up (without precision)

Source

ceil(4.345)

Return

Round a number up (with precision)

Source

ceil(4.345, precision: 2)

Return

4.35

floor

infallible

Rounds the value down to the specified precision.

Function spec

floor(value: <integer | float>, [precision: <integer>])

:: <integer | float>

required optional <types | ...>

Argument	Type	Description	Default	Required?
value	integer float	The number to round down.		yes
precision	integer	The number of decimal places to round to.		no

Examples

Round a number down (without precision)

Source

floor(4.345)

Return

Round a number down (with precision)

Source

floor(4.345, precision: 2)

Return

4.34

format_int

fallible

Formats the integer value into a string representation using the given base/radix.

Function spec

format_int(value: <integer>, [base: <integer>])

:: <string> , <error>

required optional <types | ...>

Argument	Type	Description	Default	Required?
value	integer	The number to format.		yes
base	integer	The base to format the number in. Must be between 2 and 36 (inclusive).	`10`	no

Errors

The format_int function is fallible, which means that error handling is required for these errors:

base is not between 2 and 36

Examples

Format as a hexadecimal integer

Source

format_int!(42, 16)

Return

2a

Format as a negative hexadecimal integer

Source

format_int!(-42, 16)

Return

-2a

format_number

infallible

Formats the value into a string representation of the number.

Function spec

format_number(value: <integer | float>, [scale: <integer>, decimal_separator: <string>, grouping_separator: <string>])

:: <string>

required optional <types | ...>

Argument	Type	Description	Default	Required?
value	integer float	The number to format as a string.		yes
scale	integer	The number of decimal places to display.		no
decimal_separator	string	The character to use between the whole and decimal parts of the number.	`.`	no
grouping_separator	string	The character to use between each thousands part of the number.	`,`	no

Examples

Format a number (3 decimals)

Source

format_number(1234567.89, 3, decimal_separator: ".", grouping_separator: ",")

Return

1,234,567.890

mod

fallible

Calculates the remainder of value divided by modulus.

Function spec

mod(value: <integer | float>, modulus: <integer | float>)

:: <string> , <error>

required optional <types | ...>

Argument	Type	Description	Default	Required?
value	integer float	The value the `modulus` is applied to.		yes
modulus	integer float	The `modulus` value.		yes

Errors

The mod function is fallible, which means that error handling is required for these errors:

value isn’t an integer or float

modulus isn’t an integer or float

modulus is equal to 0

Examples

Calculate the remainder of two integers

Source

remainder = mod(5, 2)

Return

round

infallible

Rounds the value to the specified precision.

Function spec

round(value: <integer | float>, [precision: <integer>])

:: <integer | float>

required optional <types | ...>

Argument	Type	Description	Default	Required?
value	integer float	The number to round.		yes
precision	integer	The number of decimal places to round to.		no

Examples

Round a number (without precision)

Source

round(4.345)

Return

Round a number (with precision)

Source

round(4.345, precision: 2)

Return

4.35

Object functions

match_datadog_query

infallible

Matches an object against a Datadog Search Syntax query.

Function spec

match_datadog_query(value: <object>, query: <string>)

:: <boolean>

required optional <types | ...>

Argument	Type	Description	Default	Required?
value	object	The object.		yes
query	string	The Datadog Search Syntax query.		yes

Examples

OR query

Source

match_datadog_query({"message": "contains this and that"}, "this OR that")

Return

true

AND query

Source

match_datadog_query({"message": "contains only this"}, "this AND that")

Facet wildcard

Source

match_datadog_query({"custom": {"name": "vector"}}, "@name:vec*")

Return

true

Tag range

Source

match_datadog_query({"tags": ["a:x", "b:y", "c:z"]}, s'b:["x" TO "z"]')

Return

true

merge

infallible

Merges the from object into the to object.

Function spec

merge(to: <object>, from: <object>, [deep: <boolean>])

:: <object>

required optional <types | ...>

Argument	Type	Description	Required?
to	object	The object to merge into.	yes
from	object	The object to merge from.	yes
deep	boolean	A deep merge is performed if `true`, otherwise only top-level fields are merged.	no

Examples

Object merge (shallow)

Source

merge(
	{
		"parent1": {
			"child1": 1,
			"child2": 2
		},
		"parent2": {
			"child3": 3
		}
	},
	{
		"parent1": {
			"child2": 4,
			"child5": 5
		}
	}
)

Return

{
  "parent1": {
    "child2": 4,
    "child5": 5
  },
  "parent2": {
    "child3": 3
  }
}

Object merge (deep)

Source

merge(
	{
		"parent1": {
			"child1": 1,
			"child2": 2
		},
		"parent2": {
			"child3": 3
		}
	},
	{
		"parent1": {
			"child2": 4,
			"child5": 5
		}
	},
	deep: true
)

Return

{
  "parent1": {
    "child1": 1,
    "child2": 4,
    "child5": 5
  },
  "parent2": {
    "child3": 3
  }
}

unnest

fallible

Unnest an array field from an object to create an array of objects using that field; keeping all other fields.

Assigning the array result of this to . will result in multiple events being emitted from remap. See the remap transform docs for more details.

This is also referred to as explodeing in some languages.

Function spec

unnest(path: <path>)

:: <array> , <error>

required optional <types | ...>

Argument	Type	Description	Default	Required?
path	path	The path of the field to unnest.		yes

Errors

The unnest function is fallible, which means that error handling is required for these errors:

Field path refers to is not an array

Examples

Unnest an array field

Source

. = unnest!(.messages)

Unnest nested an array field

Source

. = unnest!(.event.messages)

Parse functions

parse_apache_log

fallible

Parses Apache access and error log lines. Lines can be in common, combined, or default error format.

Function spec

parse_apache_log(value: <string>, format: <string>, [timestamp_format: <string>])

:: <object> , <error>

required optional <types | ...>

Argument	Type	Description	Default	Required?
value	string	The string to parse.		yes
format	string	The format to use for parsing the log.		yes
timestamp_format	string	The date/time format to use for encoding the timestamp. The time is parsed in local time if the timestamp doesn’t specify a timezone.	`%d/%b/%Y:%T %z`	no

Notices

This function has special behavior that you should be aware of.

Missing information in the log message may be indicated by -. These fields are omitted in the result.

Errors

The parse_apache_log function is fallible, which means that error handling is required for these errors:

value doesn’t match the specified format

timestamp_format isn’t a valid format string

The timestamp in value fails to parse using the provided timestamp_format

Examples

Parse via Apache log format (common)

Source

parse_apache_log!("127.0.0.1 bob frank [10/Oct/2000:13:55:36 -0700] \"GET /apache_pb.gif HTTP/1.0\" 200 2326", format: "common")

Return

{
  "host": "127.0.0.1",
  "identity": "bob",
  "message": "GET /apache_pb.gif HTTP/1.0",
  "method": "GET",
  "path": "/apache_pb.gif",
  "protocol": "HTTP/1.0",
  "size": 2326,
  "status": 200,
  "timestamp": "2000-10-10T20:55:36Z",
  "user": "frank"
}

Parse via Apache log format (combined)

Source

parse_apache_log!(
	s'127.0.0.1 bob frank [10/Oct/2000:13:55:36 -0700] "GET /apache_pb.gif HTTP/1.0" 200 2326 "http://www.seniorinfomediaries.com/vertical/channels/front-end/bandwidth" "Mozilla/5.0 (X11; Linux i686; rv:5.0) Gecko/1945-10-12 Firefox/37.0"',
	"combined",
)

Return

{
  "agent": "Mozilla/5.0 (X11; Linux i686; rv:5.0) Gecko/1945-10-12 Firefox/37.0",
  "host": "127.0.0.1",
  "identity": "bob",
  "message": "GET /apache_pb.gif HTTP/1.0",
  "method": "GET",
  "path": "/apache_pb.gif",
  "protocol": "HTTP/1.0",
  "referrer": "http://www.seniorinfomediaries.com/vertical/channels/front-end/bandwidth",
  "size": 2326,
  "status": 200,
  "timestamp": "2000-10-10T20:55:36Z",
  "user": "frank"
}

Parse via Apache log format (error)

Source

parse_apache_log!(
	s'[01/Mar/2021:12:00:19 +0000] [ab:alert] [pid 4803:tid 3814] [client 147.159.108.175:24259] I will bypass the haptic COM bandwidth, that should matrix the CSS driver!',
	"error"
)

Return

{
  "client": "147.159.108.175",
  "message": "I will bypass the haptic COM bandwidth, that should matrix the CSS driver!",
  "module": "ab",
  "pid": 4803,
  "port": 24259,
  "severity": "alert",
  "thread": "3814",
  "timestamp": "2021-03-01T12:00:19Z"
}

parse_aws_alb_log

fallible

Parses value in the Elastic Load Balancer Access format.

Function spec

parse_aws_alb_log(value: <string>)

:: <object> , <error>

required optional <types | ...>

Argument	Type	Description	Default	Required?
value	string	Access log of the Application Load Balancer.		yes

Errors

The parse_aws_alb_log function is fallible, which means that error handling is required for these errors:

value isn’t a properly formatted AWS ALB log

Examples

Parse AWS ALB log

Source

parse_aws_alb_log!(
	"http 2018-11-30T22:23:00.186641Z app/my-loadbalancer/50dc6c495c0c9188 192.168.131.39:2817 - 0.000 0.001 0.000 200 200 34 366 \"GET http://www.example.com:80/ HTTP/1.1\" \"curl/7.46.0\" - - arn:aws:elasticloadbalancing:us-east-2:123456789012:targetgroup/my-targets/73e2d6bc24d8a067 \"Root=1-58337364-23a8c76965a2ef7629b185e3\" \"-\" \"-\" 0 2018-11-30T22:22:48.364000Z \"forward\" \"-\" \"-\" \"-\" \"-\" \"-\" \"-\""
)

Return

{
  "actions_executed": "forward",
  "chosen_cert_arn": null,
  "classification": null,
  "classification_reason": null,
  "client_host": "192.168.131.39:2817",
  "domain_name": null,
  "elb": "app/my-loadbalancer/50dc6c495c0c9188",
  "elb_status_code": "200",
  "error_reason": null,
  "matched_rule_priority": "0",
  "received_bytes": 34,
  "redirect_url": null,
  "request_creation_time": "2018-11-30T22:22:48.364000Z",
  "request_method": "GET",
  "request_processing_time": 0,
  "request_protocol": "HTTP/1.1",
  "request_url": "http://www.example.com:80/",
  "response_processing_time": 0,
  "sent_bytes": 366,
  "ssl_cipher": null,
  "ssl_protocol": null,
  "target_group_arn": "arn:aws:elasticloadbalancing:us-east-2:123456789012:targetgroup/my-targets/73e2d6bc24d8a067",
  "target_host": null,
  "target_port_list": [],
  "target_processing_time": 0.001,
  "target_status_code": "200",
  "target_status_code_list": [],
  "timestamp": "2018-11-30T22:23:00.186641Z",
  "trace_id": "Root=1-58337364-23a8c76965a2ef7629b185e3",
  "type": "http",
  "user_agent": "curl/7.46.0"
}

parse_aws_cloudwatch_log_subscription_message

fallible

Parses AWS CloudWatch Logs events (configured through AWS Cloudwatch subscriptions) from the aws_kinesis_firehose source.

Function spec

parse_aws_cloudwatch_log_subscription_message(value: <string>)

:: <object> , <error>

required optional <types | ...>

Argument	Type	Description	Default	Required?
value	string	The string representation of the message to parse.		yes

Errors

The parse_aws_cloudwatch_log_subscription_message function is fallible, which means that error handling is required for these errors:

value isn’t a properly formatted AWS Cloudwatch Log subscription message

Examples

Parse AWS Cloudwatch Log subscription message

Source

parse_aws_cloudwatch_log_subscription_message!(.message)

Return

{
  "log_events": [
    {
      "id": "35683658089614582423604394983260738922885519999578275840",
      "message": "{\"bytes\":26780,\"datetime\":\"14/Sep/2020:11:45:41 -0400\",\"host\":\"157.130.216.193\",\"method\":\"PUT\",\"protocol\":\"HTTP/1.0\",\"referer\":\"https://www.principalcross-platform.io/markets/ubiquitous\",\"request\":\"/expedite/convergence\",\"source_type\":\"stdin\",\"status\":301,\"user-identifier\":\"-\"}",
      "timestamp": "2020-09-14T19:09:29.039Z"
    }
  ],
  "log_group": "test",
  "log_stream": "test",
  "message_type": "DATA_MESSAGE",
  "owner": "111111111111",
  "subscription_filters": [
    "Destination"
  ]
}

parse_aws_vpc_flow_log

fallible

Parses value in the VPC Flow Logs format.

Function spec

parse_aws_vpc_flow_log(value: <string>, [format: <string>])

:: <object> , <error>

required optional <types | ...>

Argument	Type	Description	Default	Required?
value	string	VPC Flow Log.		yes
format	string	VPC Flow Log format.		no

Errors

The parse_aws_vpc_flow_log function is fallible, which means that error handling is required for these errors:

value isn’t a properly formatted AWS VPC Flow log

Examples

Parse AWS VPC Flow log (default format)

Source

parse_aws_vpc_flow_log!("2 123456789010 eni-1235b8ca123456789 - - - - - - - 1431280876 1431280934 - NODATA")

Return

{
  "account_id": 123456789010,
  "action": null,
  "bytes": null,
  "dstaddr": null,
  "dstport": null,
  "end": 1431280934,
  "interface_id": "eni-1235b8ca123456789",
  "log_status": "NODATA",
  "packets": null,
  "protocol": null,
  "srcaddr": null,
  "srcport": null,
  "start": 1431280876,
  "version": 2
}

Parse AWS VPC Flow log (custom format)

Source

parse_aws_vpc_flow_log!(
	"- eni-1235b8ca123456789 10.0.1.5 10.0.0.220 10.0.1.5 203.0.113.5",
	"instance_id interface_id srcaddr dstaddr pkt_srcaddr pkt_dstaddr"
)

Return

{
  "dstaddr": "10.0.0.220",
  "instance_id": null,
  "interface_id": "eni-1235b8ca123456789",
  "pkt_dstaddr": "203.0.113.5",
  "pkt_srcaddr": "10.0.1.5",
  "srcaddr": "10.0.1.5"
}

parse_cef

fallible

Parses the value in CEF (Common Event Format) format. Ignores everything up to CEF header. Empty values are returned as empty strings. Surrounding quotes are removed from values.

Function spec

parse_cef(value: <string>, [translate_custom_fields: <boolean>])

:: <object> , <error>

required optional <types | ...>

Argument	Type	Description	Default	Required?
value	string	The string to parse.		yes
translate_custom_fields	boolean	Toggles translation of custom field pairs to `key: value`.		no

Notices

This function has special behavior that you should be aware of.

All values are returned as strings. We recommend manually coercing values to desired types as you see fit.

Errors

The parse_cef function is fallible, which means that error handling is required for these errors:

value isn’t a properly formatted CEF string

Examples

Parse output generated by PTA

Source

parse_cef!(
	"CEF:0|CyberArk|PTA|12.6|1|Suspected credentials theft|8|suser=mike2@prod1.domain.com shost=prod1.domain.com src=1.1.1.1 duser=andy@dev1.domain.com dhost=dev1.domain.com dst=2.2.2.2 cs1Label=ExtraData cs1=None cs2Label=EventID cs2=52b06812ec3500ed864c461e deviceCustomDate1Label=detectionDate deviceCustomDate1=1388577900000 cs3Label=PTAlink cs3=https://1.1.1.1/incidents/52b06812ec3500ed864c461e cs4Label=ExternalLink cs4=None"
)

Return

{
  "cefVersion": "0",
  "cs1": "None",
  "cs1Label": "ExtraData",
  "cs2": "52b06812ec3500ed864c461e",
  "cs2Label": "EventID",
  "cs3": "https://1.1.1.1/incidents/52b06812ec3500ed864c461e",
  "cs3Label": "PTAlink",
  "cs4": "None",
  "cs4Label": "ExternalLink",
  "deviceCustomDate1": "1388577900000",
  "deviceCustomDate1Label": "detectionDate",
  "deviceEventClassId": "1",
  "deviceProduct": "PTA",
  "deviceVendor": "CyberArk",
  "deviceVersion": "12.6",
  "dhost": "dev1.domain.com",
  "dst": "2.2.2.2",
  "duser": "andy@dev1.domain.com",
  "name": "Suspected credentials theft",
  "severity": "8",
  "shost": "prod1.domain.com",
  "src": "1.1.1.1",
  "suser": "mike2@prod1.domain.com"
}

Ignore syslog header

Source

parse_cef!(
	"Sep 29 08:26:10 host CEF:1|Security|threatmanager|1.0|100|worm successfully stopped|10|src=10.0.0.1 dst=2.1.2.2 spt=1232"
)

Return

{
  "cefVersion": "1",
  "deviceEventClassId": "100",
  "deviceProduct": "threatmanager",
  "deviceVendor": "Security",
  "deviceVersion": "1.0",
  "dst": "2.1.2.2",
  "name": "worm successfully stopped",
  "severity": "10",
  "spt": "1232",
  "src": "10.0.0.1"
}

Translate custom fields

Source

parse_cef!(
	"CEF:0|Dev|firewall|2.2|1|Connection denied|5|c6a1=2345:0425:2CA1:0000:0000:0567:5673:23b5 c6a1Label=Device IPv6 Address",
	translate_custom_fields: true
)

Return

{
  "Device IPv6 Address": "2345:0425:2CA1:0000:0000:0567:5673:23b5",
  "cefVersion": "0",
  "deviceEventClassId": "1",
  "deviceProduct": "firewall",
  "deviceVendor": "Dev",
  "deviceVersion": "2.2",
  "name": "Connection denied",
  "severity": "5"
}

parse_common_log

fallible

Parses the value using the Common Log Format (CLF).

Function spec

parse_common_log(value: <string>, [timestamp_format: <string>])

:: <object> , <error>

required optional <types | ...>

Argument	Type	Description	Default	Required?
value	string	The string to parse.		yes
timestamp_format	string	The date/time format to use for encoding the timestamp.	`%d/%b/%Y:%T %z`	no

Notices

This function has special behavior that you should be aware of.

Missing information in the log message may be indicated by -. These fields are omitted in the result.

Errors

The parse_common_log function is fallible, which means that error handling is required for these errors:

value doesn’t match the Common Log Format

timestamp_format isn’t a valid format string

The timestamp in value fails to parse using the provided timestamp_format

Examples

Parse via Common Log Format (with default timestamp format)

Source

parse_common_log!("127.0.0.1 bob frank [10/Oct/2000:13:55:36 -0700] \"GET /apache_pb.gif HTTP/1.0\" 200 2326")

Return

{
  "host": "127.0.0.1",
  "identity": "bob",
  "message": "GET /apache_pb.gif HTTP/1.0",
  "method": "GET",
  "path": "/apache_pb.gif",
  "protocol": "HTTP/1.0",
  "size": 2326,
  "status": 200,
  "timestamp": "2000-10-10T20:55:36Z",
  "user": "frank"
}

Parse via Common Log Format (with custom timestamp format)

Source

parse_common_log!(
	"127.0.0.1 bob frank [2000-10-10T20:55:36Z] \"GET /apache_pb.gif HTTP/1.0\" 200 2326",
	"%+"
)

Return

{
  "host": "127.0.0.1",
  "identity": "bob",
  "message": "GET /apache_pb.gif HTTP/1.0",
  "method": "GET",
  "path": "/apache_pb.gif",
  "protocol": "HTTP/1.0",
  "size": 2326,
  "status": 200,
  "timestamp": "2000-10-10T20:55:36Z",
  "user": "frank"
}

parse_csv

fallible

Parses a single CSV formatted row. Only the first row is parsed in case of multiline input value.

Function spec

parse_csv(value: <string>, [delimiter: <string>])

:: <array> , <error>

required optional <types | ...>

Argument	Type	Description	Default	Required?
value	string	The string to parse.		yes
delimiter	string	The field delimiter to use when parsing. Must be a single-byte utf8 character.	`,`	no

Notices

This function has special behavior that you should be aware of.

All values are returned as strings. We recommend manually coercing values to desired types as you see fit.

Errors

The parse_csv function is fallible, which means that error handling is required for these errors:

delimiter must be a single-byte utf8 character

value isn’t a valid CSV string

Examples

Parse a single CSV formatted row

Source

parse_csv!("foo,bar,\"foo \"\", bar\"")

Return

["foo","bar","foo \", bar"]

Parse a single CSV formatted row with custom delimiter

Source

parse_csv!("foo bar", delimiter: " ")

Return

["foo","bar"]

parse_duration

fallible

Parses the value into a human-readable duration format specified by unit.

Function spec

parse_duration(value: <string>, unit: <string>)

:: <float> , <error>

required optional <types | ...>

Argument	Type	Description	Default	Required?
value	string	The string of the duration.		yes
unit	string	The output units for the duration.		yes

Errors

The parse_duration function is fallible, which means that error handling is required for these errors:

value isn’t a properly formatted duration

Examples

Parse duration (milliseconds)

Source

parse_duration!("1005ms", unit: "s")

Return

1.005

parse_glog

fallible

Parses the value using the glog (Google Logging Library) format.

Function spec

parse_glog(value: <string>)

:: <object> , <error>

required optional <types | ...>

Argument	Type	Description	Default	Required?
value	string	The string to parse.		yes

Errors

The parse_glog function is fallible, which means that error handling is required for these errors:

value doesn’t match the glog format

Examples

Parse via glog

Source

parse_glog!("I20210131 14:48:54.411655 15520 main.c++:9] Hello world!")

Return

{
  "file": "main.c++",
  "id": 15520,
  "level": "info",
  "line": 9,
  "message": "Hello world!",
  "timestamp": "2021-01-31T14:48:54.411655Z"
}

parse_grok

fallible

Parses the value using the grok format. All patterns listed here are supported.

Function spec

parse_grok(value: <string>, pattern: <string>)

:: <object> , <error>

required optional <types | ...>

Argument	Type	Description	Default	Required?
value	string	The string to parse.		yes
pattern	string	The Grok pattern.		yes

Notices

This function has special behavior that you should be aware of.

We recommend using community-maintained Grok patterns when possible, as they’re more likely to be properly vetted and improved over time than bespoke patterns.

Errors

The parse_grok function is fallible, which means that error handling is required for these errors:

value fails to parse using the provided pattern

Examples

Parse using Grok

Source

parse_grok!(
	"2020-10-02T23:22:12.223222Z info Hello world",
	"%{TIMESTAMP_ISO8601:timestamp} %{LOGLEVEL:level} %{GREEDYDATA:message}"
)

Return

{
  "level": "info",
  "message": "Hello world",
  "timestamp": "2020-10-02T23:22:12.223222Z"
}

parse_groks

fallible

Parses the value using multiple grok patterns. All patterns listed here are supported.

Function spec

parse_groks(value: <string>, patterns: <array>, [aliases: <object>])

:: <object> , <error>

required optional <types | ...>

Argument	Type	Description	Default	Required?
value	string	The string to parse.		yes
patterns	array	The Grok patterns, which are tried in order until the first match.		yes
aliases	object	The shared set of grok aliases that can be referenced in the patterns to simplify them.	`true`	no

Notices

This function has special behavior that you should be aware of.

We recommend using community-maintained Grok patterns when possible, as they’re more likely to be properly vetted and improved over time than bespoke patterns.

Errors

The parse_groks function is fallible, which means that error handling is required for these errors:

value fails to parse using the provided pattern

Examples

Parse using multiple Grok patterns

Source

parse_groks!(
	"2020-10-02T23:22:12.223222Z info Hello world",
	patterns: [
		"%{common_prefix} %{_status} %{_message}",
		"%{common_prefix} %{_message}",
	],
	aliases: {
		"common_prefix": "%{_timestamp} %{_loglevel}",
		"_timestamp": "%{TIMESTAMP_ISO8601:timestamp}",
		"_loglevel": "%{LOGLEVEL:level}",
		"_status": "%{POSINT:status}",
		"_message": "%{GREEDYDATA:message}"
	}
)

Return

{
  "level": "info",
  "message": "Hello world",
  "timestamp": "2020-10-02T23:22:12.223222Z"
}

parse_int

fallible

Parses the string value representing a number in an optional base/radix to an integer.

Function spec

parse_int(value: <string>, [base: <integer>])

:: <string> , <error>

required optional <types | ...>

Argument

Type

Description

Default

Required?

value

string

The string to parse.

yes

base

integer

The base the number is in. Must be between 2 and 36 (inclusive).

If unspecified, will use the string prefix to try to determine the base: “0b”, 8 for “0” or “0o”, 16 for “0x”, and 10 otherwise

Errors

The parse_int function is fallible, which means that error handling is required for these errors:

base is not between 2 and 36

number cannot be parsed in the base

Examples

Parse decimal

Source

parse_int!("-42")

Return

-42

Parse binary

Source

parse_int!("0b1001")

Return

Parse octal

Source

parse_int!("0o42")

Return

Parse hexadecimal

Source

parse_int!("0x2a")

Return

Parse explicit base

Source

parse_int!("2a", 17)

Return

parse_json

fallible

Parses the value as JSON.

Function spec

parse_json(value: <string>, [max_depth: <integer>])

required optional <types | ...>

Argument	Type	Description	Default	Required?
value	string	The string representation of the JSON to parse.		yes
max_depth	integer	Number of layers to parse for nested JSON-formatted documents. The value must be in range 1..128.		no

Notices

This function has special behavior that you should be aware of.

Only JSON types are returned. If you need to convert a string into a timestamp, consider the parse_timestamp function.

Errors

The parse_json function is fallible, which means that error handling is required for these errors:

value isn’t a valid JSON-formatted payload

Examples

Parse JSON

Source

parse_json!("{\"key\": \"val\"}")

Return

{
  "key": "val"
}

Parse JSON with max_depth

Source

parse_json!("{\"top_level\":{\"key\": \"val\"}}", max_depth: 1)

Return

{
  "top_level": "{\"key\": \"val\"}"
}

parse_key_value

fallible

Parses the value in key/value format. Also known as logfmt.

Keys and values can be wrapped with ".
" characters can be escaped using \.

Function spec

parse_key_value(value: <string>, [key_value_delimiter: <string>, field_delimiter: <string>, whitespace: <string>, accept_standalone_key: <boolean>])

:: <object> , <error>

required optional <types | ...>

Argument	Type	Description	Default	Required?
value	string	The string to parse.		yes
key_value_delimiter	string	The string that separates the key from the value.	`=`	no
field_delimiter	string	The string that separates each key/value pair.		no
whitespace	string	Defines the acceptance of unnecessary whitespace surrounding the configured `key_value_delimiter`.	`lenient`	no
accept_standalone_key	boolean	Whether a standalone key should be accepted, the resulting object will associate such keys with boolean value `true`	`true`	no

Notices

This function has special behavior that you should be aware of.

All values are returned as strings or as an array of strings for duplicate keys. We recommend manually coercing values to desired types as you see fit.

Errors

The parse_key_value function is fallible, which means that error handling is required for these errors:

value isn’t a properly formatted key/value string

Examples

Parse logfmt log

Source

parse_key_value!(
	"@timestamp=\"Sun Jan 10 16:47:39 EST 2021\" level=info msg=\"Stopping all fetchers\" tag#production=stopping_fetchers id=ConsumerFetcherManager-1382721708341 module=kafka.consumer.ConsumerFetcherManager"
)

Return

{
  "@timestamp": "Sun Jan 10 16:47:39 EST 2021",
  "id": "ConsumerFetcherManager-1382721708341",
  "level": "info",
  "module": "kafka.consumer.ConsumerFetcherManager",
  "msg": "Stopping all fetchers",
  "tag#production": "stopping_fetchers"
}

Parse comma delimited log

Source

parse_key_value!(
	"path:\"/cart_link\", host:store.app.com, fwd: \"102.30.171.16\", dyno: web.1, connect:0ms, service:87ms, status:304, bytes:632, protocol:https",
	field_delimiter: ",",
	key_value_delimiter: ":"
)

Return

{
  "bytes": "632",
  "connect": "0ms",
  "dyno": "web.1",
  "fwd": "102.30.171.16",
  "host": "store.app.com",
  "path": "/cart_link",
  "protocol": "https",
  "service": "87ms",
  "status": "304"
}

Parse comma delimited log with standalone keys

Source

parse_key_value!(
	"env:prod,service:backend,region:eu-east1,beta",
	field_delimiter: ",",
	key_value_delimiter: ":",
)

Return

{
  "beta": true,
  "env": "prod",
  "region": "eu-east1",
  "service": "backend"
}

Parse duplicate keys

Source

parse_key_value!(
	"at=info,method=GET,path=\"/index\",status=200,tags=dev,tags=dummy",
	field_delimiter: ",",
	key_value_delimiter: "=",
)

Return

{
  "at": "info",
  "method": "GET",
  "path": "/index",
  "status": "200",
  "tags": [
    "dev",
    "dummy"
  ]
}

parse_klog

fallible

Parses the value using the klog format used by Kubernetes components.

Function spec

parse_klog(value: <string>)

:: <object> , <error>

required optional <types | ...>

Argument	Type	Description	Default	Required?
value	string	The string to parse.		yes

Errors

The parse_klog function is fallible, which means that error handling is required for these errors:

value doesn’t match the klog format

Examples

Parse via klog

Source

parse_klog!("I0505 17:59:40.692994   28133 klog.go:70] hello from klog")

Return

{
  "file": "klog.go",
  "id": 28133,
  "level": "info",
  "line": 70,
  "message": "hello from klog",
  "timestamp": "2023-05-05T17:59:40.692994Z"
}

parse_linux_authorization

fallible

Parses Linux authorization logs usually found under either /var/log/auth.log (for Debian-based systems) or /var/log/secure (for RedHat-based systems) according to Syslog format.

Function spec

parse_linux_authorization(value: <string>)

:: <object> , <error>

required optional <types | ...>

Argument	Type	Description	Default	Required?
value	string	The text containing the message to parse.		yes

Notices

This function has special behavior that you should be aware of.

The function resolves the year for messages that don’t include it. If the current month is January, and the message is for December, it will take the previous year. Otherwise, take the current year.

Errors

The parse_linux_authorization function is fallible, which means that error handling is required for these errors:

value isn’t a properly formatted Syslog message

Examples

Parse Linux authorization event

Source

parse_linux_authorization!(
	s'Mar 23 01:49:58 localhost sshd[1111]: Accepted publickey for eng from 10.1.1.1 port 8888 ssh2: RSA SHA256:foobar'
)

Return

{
  "appname": "sshd",
  "hostname": "localhost",
  "message": "Accepted publickey for eng from 10.1.1.1 port 8888 ssh2: RSA SHA256:foobar",
  "procid": 1111,
  "timestamp": "2023-03-23T01:49:58Z"
}

parse_logfmt

fallible

Parses the value in logfmt.

Keys and values can be wrapped using the " character.
" characters can be escaped by the \ character.
As per this logfmt specification, the parse_logfmt function accepts standalone keys and assigns them a Boolean value of true.

Function spec

parse_logfmt(value: <string>)

:: <object> , <error>

required optional <types | ...>

Argument	Type	Description	Default	Required?
value	string	The string to parse.		yes

Errors

The parse_logfmt function is fallible, which means that error handling is required for these errors:

value isn’t a properly formatted key/value string

Examples

Parse logfmt log

Source

parse_logfmt!(
	"@timestamp=\"Sun Jan 10 16:47:39 EST 2021\" level=info msg=\"Stopping all fetchers\" tag#production=stopping_fetchers id=ConsumerFetcherManager-1382721708341 module=kafka.consumer.ConsumerFetcherManager"
)

Return

{
  "@timestamp": "Sun Jan 10 16:47:39 EST 2021",
  "id": "ConsumerFetcherManager-1382721708341",
  "level": "info",
  "module": "kafka.consumer.ConsumerFetcherManager",
  "msg": "Stopping all fetchers",
  "tag#production": "stopping_fetchers"
}

parse_nginx_log

fallible

Parses Nginx access and error log lines. Lines can be in combined, or error format.

Function spec

parse_nginx_log(value: <string>, format: <string>, [timestamp_format: <string>])

:: <object> , <error>

required optional <types | ...>

Argument	Type	Description	Default	Required?
value	string	The string to parse.		yes
format	string	The format to use for parsing the log.		yes
timestamp_format	string	The date/time format to use for encoding the timestamp. The time is parsed in local time if the timestamp doesn’t specify a timezone. The default format is `%d/%b/%Y:%T %z` for combined logs and `%Y/%m/%d %H:%M:%S` for error logs.	`%d/%b/%Y:%T %z`	no

Notices

This function has special behavior that you should be aware of.

Missing information in the log message may be indicated by -. These fields are omitted in the result.

Errors

The parse_nginx_log function is fallible, which means that error handling is required for these errors:

value doesn’t match the specified format

timestamp_format isn’t a valid format string

The timestamp in value fails to parse using the provided timestamp_format

Examples

Parse via Nginx log format (combined)

Source

parse_nginx_log!(
    s'172.17.0.1 - alice [01/Apr/2021:12:02:31 +0000] "POST /not-found HTTP/1.1" 404 153 "http://localhost/somewhere" "Mozilla/5.0 (Windows NT 6.1) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/72.0.3626.119 Safari/537.36" "2.75"',
    "combined",
)

Return

{
  "agent": "Mozilla/5.0 (Windows NT 6.1) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/72.0.3626.119 Safari/537.36",
  "client": "172.17.0.1",
  "compression": "2.75",
  "method": "POST",
  "path": "/not-found",
  "protocol": "HTTP/1.1",
  "referer": "http://localhost/somewhere",
  "request": "POST /not-found HTTP/1.1",
  "size": 153,
  "status": 404,
  "timestamp": "2021-04-01T12:02:31Z",
  "user": "alice"
}

Parse via Nginx log format (error)

Source

parse_nginx_log!(
    s'2021/04/01 13:02:31 [error] 31#31: *1 open() "/usr/share/nginx/html/not-found" failed (2: No such file or directory), client: 172.17.0.1, server: localhost, request: "POST /not-found HTTP/1.1", host: "localhost:8081"',
    "error"
)

Return

{
  "cid": 1,
  "client": "172.17.0.1",
  "host": "localhost:8081",
  "message": "open() \"/usr/share/nginx/html/not-found\" failed (2: No such file or directory)",
  "pid": 31,
  "request": "POST /not-found HTTP/1.1",
  "server": "localhost",
  "severity": "error",
  "tid": 31,
  "timestamp": "2021-04-01T13:02:31Z"
}

parse_query_string

infallible

Parses the value as a query string.

Function spec

parse_query_string(value: <string>)

:: <object>

required optional <types | ...>

Argument	Type	Description	Default	Required?
value	string	The string to parse.		yes

Notices

This function has special behavior that you should be aware of.

All values are returned as strings. We recommend manually coercing values to desired types as you see fit. Empty keys and values are allowed.

Examples

Parse query string

Source

parse_query_string("foo=%2B1&bar=2&bar=3&xyz")

Return

{
  "bar": [
    "2",
    "3"
  ],
  "foo": "+1",
  "xyz": ""
}

Parse Ruby on Rails' query string

Source

parse_query_string("?foo%5b%5d=1&foo%5b%5d=2")

Return

{
  "foo[]": [
    "1",
    "2"
  ]
}

parse_regex

fallible

Parses the value via the provided Regex pattern.

This function differs from the parse_regex_all function in that it returns only the first match.

Function spec

parse_regex(value: <string>, pattern: <regex>, [numeric_groups: <regex>])

:: <object> , <error>

required optional <types | ...>

Argument	Type	Description	Required?
value	string	The string to search.	yes
pattern	regex	The regular expression pattern to search against.	yes
numeric_groups	regex	If true, the index of each group in the regular expression is also captured. The 0th index will contain the whole match.	no

Notices

This function has special behavior that you should be aware of.

VRL aims to provide purpose-specific parsing functions for common log formats. Before reaching for the parse_regex function, see if a VRL parse_* function already exists for your format. If not, we recommend opening an issue to request support for the desired format.

All values are returned as strings. We recommend manually coercing values to desired types as you see fit.

Errors

The parse_regex function is fallible, which means that error handling is required for these errors:

value fails to parse using the provided pattern

Examples

Parse using Regex (with capture groups)

Source

parse_regex!("first group and second group.", r'(?P<number>.*?) group')

Return

{
  "number": "first"
}

Parse using Regex (without capture groups)

Source

parse_regex!("first group and second group.", r'(\w+) group', numeric_groups: true)

Return

{
  "0": "first group",
  "1": "first"
}

parse_regex_all

fallible

Parses the value via the provided Regex pattern.

This function differs from the parse_regex function in that it returns all matches, not just the first.

Function spec

parse_regex_all(value: <string>, pattern: <regex>, [numeric_groups: <regex>])

:: <array> , <error>

required optional <types | ...>

Argument	Type	Description	Required?
value	string	The string to search.	yes
pattern	regex	The regular expression pattern to search against.	yes
numeric_groups	regex	If `true`, the index of each group in the regular expression is also captured. The 0th index contains the whole match.	no

Notices

This function has special behavior that you should be aware of.

All values are returned as strings. We recommend manually coercing values to desired types as you see fit.

Errors

The parse_regex_all function is fallible, which means that error handling is required for these errors:

value fails to parse via the provided pattern

Examples

Parse using Regex (all matches)

Source

parse_regex_all!("first group and second group.", r'(?P<number>\w+) group', numeric_groups: true)

Return

[{"0":"first group","1":"first","number":"first"},{"0":"second group","1":"second","number":"second"}]

parse_ruby_hash

fallible

Parses the value as ruby hash.

Function spec

parse_ruby_hash(value: <string>)

:: <object> , <error>

required optional <types | ...>

Argument	Type	Description	Default	Required?
value	string	The string representation of the ruby hash to parse.		yes

Notices

This function has special behavior that you should be aware of.

Only ruby types are returned. If you need to convert a string into a timestamp, consider the parse_timestamp function.

Errors

The parse_ruby_hash function is fallible, which means that error handling is required for these errors:

value isn’t a valid ruby hash formatted payload

Examples

Parse ruby hash

Source

parse_ruby_hash!(s'{ "test" => "value", "testNum" => 0.2, "testObj" => { "testBool" => true, "testNull" => nil } }')

Return

{
  "test": "value",
  "testNum": 0.2,
  "testObj": {
    "testBool": true,
    "testNull": null
  }
}

parse_syslog

fallible

Parses the value in Syslog format.

Function spec

parse_syslog(value: <string>)

:: <object> , <error>

required optional <types | ...>

Argument	Type	Description	Default	Required?
value	string	The text containing the Syslog message to parse.		yes

Notices

This function has special behavior that you should be aware of.

The function makes a best effort to parse the various Syslog formats that exists out in the wild. This includes RFC 6587, RFC 5424, RFC 3164, and other common variations (such as the Nginx Syslog style).

All values are returned as strings. We recommend manually coercing values to desired types as you see fit.

Errors

The parse_syslog function is fallible, which means that error handling is required for these errors:

value isn’t a properly formatted Syslog message

Examples

Parse Syslog log (5424)

Source

parse_syslog!(
	s'<13>1 2020-03-13T20:45:38.119Z dynamicwireless.name non 2426 ID931 [exampleSDID@32473 iut="3" eventSource= "Application" eventID="1011"] Try to override the THX port, maybe it will reboot the neural interface!'
)

Return

{
  "appname": "non",
  "exampleSDID@32473": {
    "eventID": "1011",
    "eventSource": "Application",
    "iut": "3"
  },
  "facility": "user",
  "hostname": "dynamicwireless.name",
  "message": "Try to override the THX port, maybe it will reboot the neural interface!",
  "msgid": "ID931",
  "procid": 2426,
  "severity": "notice",
  "timestamp": "2020-03-13T20:45:38.119Z",
  "version": 1
}

parse_timestamp

fallible

Parses the value in strptime format.

Function spec

parse_timestamp(value: <string>, format: <string>)

:: <timestamp> , <error>

required optional <types | ...>

Argument	Type	Description	Default	Required?
value	string	The text of the timestamp.		yes
format	string	The strptime format.		yes

Errors

The parse_timestamp function is fallible, which means that error handling is required for these errors:

value fails to parse using the provided format

Examples

Parse timestamp

Source

parse_timestamp!("10-Oct-2020 16:00+00:00", format: "%v %R %:z")

Return

2020-10-10T16:00:00Z

parse_tokens

fallible

Parses the value in “token” format. A token is considered to be one of the following:

A word surrounded by whitespace.
Text delimited by double quotes: "..". Quotes can be included in the token if they are escaped by a backslash (\).
Text delimited by square brackets: [..]. Closing square brackets can be included in the token if they are escaped by a backslash (\).

Function spec

parse_tokens(value: <string>)

:: <array> , <error>

required optional <types | ...>

Argument	Type	Description	Default	Required?
value	string	The string to tokenize.		yes

Notices

This function has special behavior that you should be aware of.

All token values are returned as strings. We recommend manually coercing values to desired types as you see fit.

Errors

The parse_tokens function is fallible, which means that error handling is required for these errors:

value isn’t a properly formatted tokenized string

Examples

Parse tokens

Source

parse_tokens(
	"A sentence \"with \\\"a\\\" sentence inside\" and [some brackets]"
)

Return

["A","sentence","with \\\"a\\\" sentence inside","and","some brackets"]

parse_url

fallible

Parses the value in URL format.

Function spec

parse_url(value: <string>, [default_known_ports: <boolean>])

:: <object> , <error>

required optional <types | ...>

Argument	Type	Description	Default	Required?
value	string	The text of the URL.		yes
default_known_ports	boolean	If true and the port number is not specified in the input URL string (or matches the default port for the scheme), it will be populated from well-known ports for the following schemes: `http`, `https`, `ws`, `wss`, and `ftp`.		no

Errors

The parse_url function is fallible, which means that error handling is required for these errors:

value isn’t a properly formatted URL

Examples

Parse URL

Source

parse_url!("ftp://foo:bar@vector.dev:4343/foobar?hello=world#123")

Return

{
  "fragment": "123",
  "host": "vector.dev",
  "password": "bar",
  "path": "/foobar",
  "port": 4343,
  "query": {
    "hello": "world"
  },
  "scheme": "ftp",
  "username": "foo"
}

Parse URL with default port

Source

parse_url!("https://vector.dev", default_known_ports: true)

Return

{
  "fragment": null,
  "host": "vector.dev",
  "password": "",
  "path": "/",
  "port": 443,
  "query": {},
  "scheme": "https",
  "username": ""
}

parse_user_agent

infallible

Parses the value as a user agent string. Which has a loosely defined format so this parser only provides best effort guarantee.

Function spec

parse_user_agent(value: <string>, [mode: <string>])

:: <object>

required optional <types | ...>

Argument	Type	Description	Default	Required?
value	string	The string to parse.		yes
mode	string	Determines performance and reliability characteristics.	`fast`	no

Notices

This function has special behavior that you should be aware of.

All values are returned as strings or as null. We recommend manually coercing values to desired types as you see fit.

Different modes return different schema.

Field which were not parsed out are set as null.

Examples

Fast mode

Source

parse_user_agent(
	"Mozilla Firefox 1.0.1 Mozilla/5.0 (X11; U; Linux i686; de-DE; rv:1.7.6) Gecko/20050223 Firefox/1.0.1"
)

Return

{
  "browser": {
    "family": "Firefox",
    "version": "1.0.1"
  },
  "device": {
    "category": "pc"
  },
  "os": {
    "family": "Linux",
    "version": null
  }
}

Reliable mode

Source

parse_user_agent(
	"Mozilla/4.0 (compatible; MSIE 7.66; Windows NT 5.1; SV1; .NET CLR 1.1.4322)",
	mode: "reliable"
)

Return

{
  "browser": {
    "family": "Internet Explorer",
    "version": "7.66"
  },
  "device": {
    "category": "pc"
  },
  "os": {
    "family": "Windows XP",
    "version": "NT 5.1"
  }
}

Enriched mode

Source

parse_user_agent(
	"Opera/9.80 (J2ME/MIDP; Opera Mini/4.3.24214; iPhone; CPU iPhone OS 4_2_1 like Mac OS X; AppleWebKit/24.783; U; en) Presto/2.5.25 Version/10.54",
	mode: "enriched"
)

Return

{
  "browser": {
    "family": "Opera Mini",
    "major": "4",
    "minor": "3",
    "patch": "24214",
    "version": "10.54"
  },
  "device": {
    "brand": "Apple",
    "category": "smartphone",
    "family": "iPhone",
    "model": "iPhone"
  },
  "os": {
    "family": "iOS",
    "major": "4",
    "minor": "2",
    "patch": "1",
    "patch_minor": null,
    "version": "4.2.1"
  }
}

parse_xml

fallible

Parses the value as XML.

Function spec

parse_xml(value: <string>, [include_attr: <boolean>, attr_prefix: <string>, text_key: <string>, always_use_text_key: <boolean>, parse_bool: <boolean>, parse_null: <boolean>, parse_number: <boolean>])

:: <object> , <error>

required optional <types | ...>

Argument	Type	Description	Default	Required?
value	string	The string representation of the XML document to parse.		yes
include_attr	boolean	Include XML tag attributes in the returned object.	`true`	no
attr_prefix	string	String prefix to use for XML tag attribute keys.	`@`	no
text_key	string	Key name to use for expanded text nodes.	`text`	no
always_use_text_key	boolean	Always return text nodes as `{"<text_key>": "value"}.`		no
parse_bool	boolean	Parse “true” and “false” as boolean.	`true`	no
parse_null	boolean	Parse “null” as null.	`true`	no
parse_number	boolean	Parse numbers as integers/floats.	`true`	no

Notices

This function has special behavior that you should be aware of.

Valid XML must contain exactly one root node. Always returns an object.

Errors

The parse_xml function is fallible, which means that error handling is required for these errors:

value isn’t a valid XML document

Examples

Parse XML

Source

value = s'<book category="CHILDREN"><title lang="en">Harry Potter</title><author>J K. Rowling</author><year>2005</year></book>';

parse_xml!(value, text_key: "value", parse_number: false)

Return

{
  "book": {
    "@category": "CHILDREN",
    "author": "J K. Rowling",
    "title": {
      "@lang": "en",
      "value": "Harry Potter"
    },
    "year": "2005"
  }
}