1 of 80

Field Transformation

Current version v0.2.2

The Field Transformation action acts as a container that enables users to perform a wide range of operations on data, including encoding and decoding various types of encryption, format conversion, file compression and decompression, data structure analysis, and much more. The results are stored in new events fields.

Find it in the Actions tab and drag it onto the canvas to use it.

To open the configuration, click the Action in the canvas and select Configuration.

In order to configure this action, you must first link it to a Listener or other Action. Go to Building a Pipeline to learn how to link.

Field to transform

Choose a field from the linked Listener/Action to transform in your Action using the drop-down.

Add as many fields as required using the Add New Field button.

Operations

See a comprehensive list of all the available operations for this Action.

Please bear in mind that the options available in this window will depend on the field to transform.

Add as many Operations as required using Add Operation.

You can also use the arrow keys on your keyboard to navigate up and down the list.

If you have added more than one operation, you can reorder them by dragging and dropping them into position.

Test your operation

Before saving your action, you can test it to see the outcome.

Type a message in the Input field and see it transformed in the Output field after passing through the selected operation(s).

Output field

Give a name to the transformed field and click Save to complete.

Example

Here is an example of a data set on the Bytes in/out from IP addresses.

We can use the field transformation operations to reduce the quantity of data sent.

We have a Syslog Listener, connected to a Parser.

Click if you need help configuring the Parser

Configure the parser as follows:

Paste input:

518;650;192.168.70.224;60045;192.168.70.210;3871;server.example.com

This is the data in its raw format.

Select Manual in the parser drop-down, go to code mode using the button on the right, and paste this log:

{fieldName1:csv(separator=";", indices=[0:string(alias="BYTES_IN"),1:string(alias="BYTES_OUT"),2:string(alias="SOURCE_IP_ADDRESS"),3:string(alias="SOURCE_PORT"),4:string(alias="DESTINATION_IP_ADDRESS"),5:string(alias="DESTINATION_PORT"),6:string(alias="DESTINATION_HOST")], totalColumns=7)}

You have manually parsed the raw data into separate fields. This is reflected in the output field.

Link the Parser to the Field Transformation action and open its configuration.

We will use the To IP Hex and CRC32 operations.

Input

Output

DESTINATION_IP_ADDRESS: 192.168.70.210518

DestinationIPAddressHex: c0.a8.46.d2.224

DESTINATION_HOST: server.example.com

DestinationHostCRC32:

0876633F

Destination IP to Hex

Transform the Destination IP to hexadecimal to reduce the number of characters.

Original IP

Hexadecimal

192.168.70.210518

c0.a8.46.d2.224

Field>Parser: DESTINATION_IP_ADDRESS
Operation: To IP Hex
Output Field: DestinationIPAddessHex

Add a new field for Destination Host to CRC32

Codify the Destination Host as crc32 to transform the machine name into 8 characters.

Original

CRC32

server.example.com

0876633F

Field>Parser: DESTINATION_HOST
Operation: Crc32
Output field: DestinationHostCrc32

Field Transformation Operations

A comprehensive list of the operations available in the Field Tranformation Action.

Operation

Description

Example

Converts a size in bytes to a human-readable string.

Input data - 134367
Output data - 131.22 KiB

Converts values from one unit of measurement to another.

Input data - 5000
Input units - Square foot (sq ft)
Output units - Square metre (sq m)
Output data - 464.515215

Converts a unit of data to another format.

Input data - 2
Input units - Megabits (Mb)
Output units - Kilobytes (KB)
Output data - 250

Converts values from one unit of length to another.

Input data - 100
Input units - Metres (m)
Output units - Yards (yd)
Output data - 109.3613298

Converts values from one unit of mass to another.

Input data - 100
Input units - Kilogram (kg)
Output units - Pound (lb)
Output data - 220.4622622

Converts values from one unit of speed to another.

Input data - 200
Input units - Kilometres per hour (km/h)
Output units - Miles per hour (mph)
Output data - 124.2841804

Counts the amount of times a given string occurs in your input data.

Input data - This is a sample test
Search - test
Search Type - simple
Output data - 1

Calculates an 8-bit Cyclic Redundancy Check (CRC) value for a given input.

Input data - hello 1234
Output data - C7

Calculates an 16-bit Cyclic Redundancy Check (CRC) value for a given input.

Input data - hello 1234
Output data - 57D4

Calculates an 24-bit Cyclic Redundancy Check (CRC) value for a given input.

Input data - hello 1234
Output data - 3B6473

Calculates an 32-bit Cyclic Redundancy Check (CRC) value for a given input.

Input data - hello 1234
Output data - 7ED8D648

Obfuscates all digits of a credit card number except for the last 4 digits.

Input data - 1111222233334444
Output data - ************4444

Converts a CSV file to JSON format.

Input data -

First name,Last name,Age,City John,Wick,20,New-York Tony,Stark,30,Madrid

Cell delimiter - ,
Format - Array of dictionaries
Output data -

[ { "First name": "John", "Last name": "Wick", "Age": "20", "City": "New-York" }, { "First name": "Tony", "Last name": "Stark", "Age": "30", "City": "Madrid" } ]

Defangs an IP address to prevent it from being recognized.

Input data - 192.168.1.1
Output data - 192[.]168[.]1[.]1

Defangs a URL to prevent it from being recognized as a clickable link.

Input data - https://example.com
Escape Dots - true
Escape HTTP - true
Escape ://* - false
Process Type - Everything
Output data - hxxps://example[.]com

Divides a list of numbers provided in the input string, separated by a specific delimiter.

Input data - 26:2:4
Delimiter - Colon
Output data - 3.25

Analyzes a URI into its individual components.

Input data -

https://user:pass@example.com:8080/path/to/resource?key=value#fragment

Output data -

Scheme: https Host: example.com:8080 Path: /path/to/resource Arguments: map[key:[value]] User: user Password: pass

Escapes specific characters in a string

Input data - She said, "Hello, world!"
Escape Level - Special chars
Escape Quote - "
JSON compatible -false
Output data - She said, \"Hello, world!\"

Extracts all the IPv4 and IPv6 addresses from a block of text or data.

Input data -

User logged in from 192.168.1.1. Another login detected from 10.0.0.5.

Output data -

192.168.1.1

10.0.0.5

Makes defanged IP addresses valid.

Input data - 192[.]168[.]1[.]1
Output data - 192.168.1.1

Makes defanged URLs valid.

Input data - hxxps://example[.]com
Escape Dots - true
Escape HTTP - true
Escape ://* - false
Process Type - Everything
Output data - https://example.com

Splits the input string using a specified delimiter and filters.

Input data -

Error: File not found Warning: Low memory Info: Operation completed Error: Disk full

Delimiter - Line feed
Regex - ^Error
Invert - false
Output data -

Error: File not found Error: Disk full

Finds values in a string and replace them with others.

Input data - The server encountered an error while processing your request.
Substring to find - error
Replacement - issue
Output data - The server encountered an issue while processing your request.

Decodes data from a Base64 string back into its raw format.

Input data - SGVsbG8sIE9udW0h
Strict Mode - true
Output data - Hello, Onum!

Converta hexadecimal-encoded data back into its original form.

Input data - 48 65 6c 6c 6f 20 57 6f 72 6c 64
Delimiter - Space
Output data - Hello World

Converts a timestamp into a human-readable date string.

Input data - 978346800
Time Unit - Seconds
Timezone Output - UTC
Format Output - Mon 2 January 2006 15:04:05 UTC
Output data - Mon 1 January 2001 11:00:00 UTC

Converts an IP address (either IPv4 or IPv6) to its hexadecimal representation.

Input data - 192.168.1.1
Output data - c0a80101

Reduces the size of a JSON file by removing unnecessary characters from it.

Input data -

{ "name": "John Doe", "age": 30, "isActive": true, "address": { "city": "New York", "zip": "10001" } }

Output data -

{"name":"John Doe","age":30,"isActive":true,"address":{"city":"New York","zip":"10001"}}

Converts a JSON file to CSV format.

Input data -

[ { "First name": "John", "Last name": "Wick", "Age": "20", "City": "New-York" }, { "First name": "Tony", "Last name": "Stark", "Age": "30", "City": "Madrid" } ]

Cell delimiter - ,
Row delimiter - /n
Output data -

First name,Last name,Age,City John,Wick,20,New-York Tony,Stark,30,Madrid

Decodes the payload in a JSON Web Token string.

Input data - eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiaWF0IjoxNTE2MjM5MDIyfQ.SflKxwRJSMeKKF2QT4fwpMeJf36POk6yJV_adQssw5c
Output data - {"sub":"1234567890","name":"John Doe","iat":1516239022}

Generates a Keccak cryptographic hash function from a given input.

Input data - Hello World !
Size - 256
Output data -3ea2f1d0abf3fc66cf29eebb70cbd4e7fe762ef8a09bcc06c8edf641230afec0

Produces a MD2 hash string from a given input.

Input data - Hello World!
Output data - 315f7c67223f01fb7cab4b95100e872e

Produces a MD4 hash string from a given input.

Input data - Hello World!
Output data -b2a5cc34fc21a764ae2fad94d56fadf6

Produces a MD5 hash string from a given input.

Input data - Hello World!
Output data -d41d8cd98f00b204e9800998ecf8427e

Calculates the median of given values.

Input data - 10, 5, 20, 15, 25
Delimiter - ,
Output data - 15

Calculates the result of the multiplication of given values.

Input data - 2, 3, 5
Delimiter - ,
Output data - 30

Pads each input line with a specified number of characters.

Input data - Apple Banana Cherry
Pad position - Start
Pad line - 7
Character - >>>
Output data -

>>> >>>Apple >>> >>>Banana >>> >>>Cherry

Parses a string and returns an integer of the specified base.

Input data - 100
Base - 2
Output data -4

Takes UNIX file permission strings and converts them to code format or vice versa.

Input data - -rwxr-xr--
Output data -

Textual representation: -rwxr-xr-- Octal representation: 0754 +---------+-------+-------+-------+ | | User | Group | Other | +---------+-------+-------+-------+ | Read | X | X | X | +---------+-------+-------+-------+ | Write | X | | | +---------+-------+-------+-------+ | Execute | X | X | | +---------+-------+-------+-------+

Extracts or manipulates parts of your input strings that match a specific regular expression pattern.

Input data - 100
Base - 2
Output data -4

Removes whitespace and other characters characters from a string.

Input data -

Hello World!

This is a test.

Spaces - true
Carriage returns - false
Line feeds - true
Tabs - false
Form feeds - false
Full stops - true
Output data -

HelloWorld!Thisisatest

Reverses the order of the characters in a string.

Input data - Hello World!
Reverse mode - Character
Output data - !dlroW olleH

Returns the SHA0 hash of a given string.

Input data - Hello World!
Output data - 1261178ff9a732aacfece0d8b8bd113255a57960

Returns the SHA1 hash of a given string.

Input data - Hello World!
Output data - 2ef7bde608ce5404e97d5f042f95f89f1c232871

Returns the SHA2 hash of a given string.

Input data - Hello World!
Size - 512
Output data - f4d54d32e3523357ff023903eaba2721e8c8cfc7702663782cb3e52faf2c56c002cc3096b5f2b6df870be665d0040e9963590eb02d03d166e52999cd1c430db1

Returns the SHA3 hash of a given string.

Input data - Hello World!
Size - 512
Output data - 32400b5e89822de254e8d5d94252c52bdcb27a3562ca593e980364d9848b8041b98eabe16c1a6797484941d2376864a1b0e248b0f7af8b1555a778c336a5bf48

Returns the SHAKE hash of a given string.

Input data - Hello World!
Capacity - 256
Size - 512
Output data - 35259d2903a1303d3115c669e2008510fc79acb50679b727ccb567cc3f786de3553052e47d4dd715cc705ce212a92908f4df9e653fa3653e8a7855724d366137

Shuffles the characters of a given string.

Input data - Hello World!
Delimiter - Nothing (separate chars)
Output data - rH Wl!odolle

Returns the SM3 cryptographic hash function of a given string.

Input data - Hello World!
Length - 64
Output data - 0ac0a9fef0d212aa

Sorts a list of strings separated by a specified delimiter according to the provided sorting order.

Input data - banana,apple,orange,grape
Delimiter - Comma
Order - Alphabetical (case sensitive)
Reverse - false
Output data - apple,banana,grape,orange

Extracts characters from a given string.

Input data - +34678987678
Start Index - 3
Length - 9
Output data - 678987678

Calculates the result of the subtraction of given values.

Input data - 10, 5, 2
Delimiter - Comma
Output data - 3

Calculates the total of given values.

Input data - 10, 5, 2
Delimiter - Comma
Output data - 17

Swaps the case of a given string.

Input data - Hello World!
Output data - hELLO wORLD!

Encodes raw data into an ASCII Base64 string.

Input data - Hello, Onum!
Output data - SGVsbG8sIE9udW0h

Converts an integer to its corresponding hexadecimal code.

Output data - Hello World!
Delimiter - Space
Input data - 48 65 6c 6c 6f 20 57 6f 72 6c 64

Converts the characters of a string to lower case.

Input data - Hello World!
Output data - hello world!

Transforms a string representing a date into a timestamp.

Input data - 2006-01-02
Format - DateOnly
Output data - 2006-01-02T00:00:00Z

Parses a datetime string in UTC and returns the corresponding UNIX timestamp.

Input data - Mon 1 January 2001 11:00:00
Unit - Seconds
Output data - 978346800

Converts the characters of a string to upper case.

Input data - Hello World!
Output data - HELLO WORLD!

Converts a date and time from one format to another.

Input data - 2024-10-24T14:11:13Z
Input Format - 2006-01-02T15:04:05Z
Input Timezone - UTC+1
Output Format - 02/01/2006 15:04:05
Output Timezone - UTC+8
Output data - 24/10/2024 21:11:13

Removes escape characters from a given string.

Input data - She said, \"Hello, world!\"
Output data - She said, "Hello, world!"

Decodes a URL and returns its corresponding URL-decoded string.

Input data - https%3A%2F%2Fexample.com%2Fsearch%3Fq%3DHello+World%21
Output data - https://example.com/search?q=Hello World!

Encodes a URL-decoded string back to its original URL format,

Input data - https://example.com/search?q=Hello World!
Output data - ttps%3A%2F%2Fexample.com%2Fsearch%3Fq%3DHello+World%21

Arithmetic / Logic

Divide Operation

Description

This operation divides a list of numbers provided in the input string, using the specified delimiter to separate the numbers.

Data types

These are the input/output expected data types for this operation:

Input data

- List of numbers you want to divide, separated by a specified delimiter.

Output data

- Result of the division of the numbers in your input string.

Parameters

These are the parameters you need to configure to use this operation (mandatory parameters are marked with a *):

Delimiter*

Choose the delimiter that separates the numbers in your input data:

Line feed - Select this to will each line of text as a separate value.
Space - Your numbers are separated by spaces.
Comma - Your numbers are separated by commas (,)
Semi-colon - Your numbers are separated by semi-colons (;)
Colon - Your numbers are separated by colons (:)
CRLF - Carriage return line feed (CRLF) is a control character that originally referred to moving the carriage on typewriters back to the starting position. In computing, it’s used in classic Mac OS and some Windows-based systems to mark the end of a line. If your input uses \r as the line-ending character, you can set the delimiter to \r to correctly separate values. For example: 100\r200\r300

Example

Suppose you want to divide a series of numbers in your input strings. They are separated by colons (:). To do it:

In your Pipeline, open the required Action configuration and select the input Field.
In the Operation field, choose Divide Operation.
Set Delimiter to Colon.
Give your Output field a name and click Save. You'll get the division results. For example:

26:2:4 -> 3.25

You can try out operations with specific values using the Input field above the operation. You can enter the value in the example above and check the result in the Output field.

Median

Description

This operation is used to calculate the median value of a set of numbers. The median is a statistical measure representing the middle value of a sorted dataset. It divides the data into two halves, with 50% of the data points below and 50% above the median.

Data types

These are the input/output expected data types for this operation:

Input data

- List of numbers separated by a specified delimiter.

Output data

- The result of the median.

Parameters

These are the parameters you need to configure to use this operation (mandatory parameters are marked with a *):

Delimiter*

Choose the delimiter that separates the numbers in your input data:

Line feed - Select this to will each line of text as a separate value.
Space - Your numbers are separated by spaces.
Comma - Your numbers are separated by commas (,)
Semi-colon - Your numbers are separated by semi-colons (;)
Colon - Your numbers are separated by colons (:)
CRLF - Carriage return line feed (CRLF) is a control character that originally referred to moving the carriage on typewriters back to the starting position. In computing, it’s used in classic Mac OS and some Windows-based systems to mark the end of a line. If your input uses \r as the line-ending character, you can set the delimiter to \r to correctly separate values. For example: 100\r200\r300

Example

Suppose you want to calculate the median a series of numbers in your input strings. They are separated by commas (,). To do it:

In your Pipeline, open the required Action configuration and select the input Field.
In the Operation field, choose Median.
Set Delimiter to Comma.
Give your Output field a name and click Save. You'll get the median of the numbers in your input data. For example:

10, 5, 20, 15, 25 -> 15

You can try out operations with specific values using the Input field above the operation. You can enter the value in the example above and check the result in the Output field.

Multiply Operation

Description

This operation allows you to multiply numbers in a dataset by a specified value. It processes numerical input and applies the multiplication operation to each number individually. This is useful for scaling data, performing simple arithmetic, or manipulating numerical datasets.

Data types

These are the input/output expected data types for this operation:

Input data

- Input string containing numbers to multiply.

Output data

- The result of the multiplication.

Parameters

These are the parameters you need to configure to use this operation (mandatory parameters are marked with a *):

Delimiter*

Choose the delimiter that separates the numbers in your input data:

Line feed - Select this to will each line of text as a separate value.
Space - Your numbers are separated by spaces.
Comma - Your numbers are separated by commas (,)
Semi-colon - Your numbers are separated by semi-colons (;)
Colon - Your numbers are separated by colons (:)
CRLF - Carriage return line feed (CRLF) is a control character that originally referred to moving the carriage on typewriters back to the starting position. In computing, it’s used in classic Mac OS and some Windows-based systems to mark the end of a line. If your input uses \r as the line-ending character, you can set the delimiter to \r to correctly separate values. For example: 100\r200\r300

Example

Suppose you want to multiply a series of numbers in your input strings. They are separated by commas (,). To do it:

In the Operation field, choose Multiply Operation.
Set Delimiter to Comma.
Give your Output field a name and click Save. You'll get the multiplication of the numbers in your input data. For example:

You can try out operations with specific values using the Input field above the operation. You can enter the value in the example above and check the result in the Output field.

Subtract Operation

Description

This operation performs arithmetic subtraction between numbers. This operation is useful for calculations, data manipulation, and analyzing numerical differences.

Data types

These are the input/output expected data types for this operation:

Input data

- Input string containing numbers to subtract.

Output data

- The result of the subtraction.

Parameters

These are the parameters you need to configure to use this operation (mandatory parameters are marked with a *):

Delimiter*

Choose the delimiter that separates the numbers in your input data. enter one of the following:

Line feed - Select this to will each line of text as a separate value.
Space - Your numbers are separated by spaces.
Comma - Your numbers are separated by commas (,)
Semi-colon - Your numbers are separated by semi-colons (;)
Colon - Your numbers are separated by colons (:)
CRLF - Carriage return line feed (CRLF) is a control character that originally referred to moving the carriage on typewriters back to the starting position. In computing, it’s used in classic Mac OS and some Windows-based systems to mark the end of a line. If your input uses \r as the line-ending character, you can set the delimiter to \r to correctly separate values. For example: 100\r200\r300

Example

Suppose you want to get the subtraction of a series of numbers in your input strings. They are separated by commas (,). To do it:

In your Pipeline, open the required Action configuration and select the input Field.
In the Operation field, choose Subtract Operation.
Set Delimiter to Comma.
Give your Output field a name and click Save. You'll get the subtraction of the numbers in your input data. For example:

10, 5, 2 -> 3

You can try out operations with specific values using the Input field above the operation. You can enter the value in the example above and check the result in the Output field.

Sum Operation

Description

This operation calculates the total sum of a series of numbers provided as input. It is a simple yet powerful tool for numerical data analysis, enabling quick summation of datasets or values.

Data types

These are the input/output expected data types for this operation:

Input data

- Input string containing numbers to sum.

Output data

- The result of the total sum.

Parameters

These are the parameters you need to configure to use this operation (mandatory parameters are marked with a *):

Delimiter*

Choose the delimiter that separates the numbers in your input data. enter one of the following:

Line feed - Select this to will each line of text as a separate value.
Space - Your numbers are separated by spaces.
Comma - Your numbers are separated by commas (,)
Semi-colon - Your numbers are separated by semi-colons (;)
Colon - Your numbers are separated by colons (:)
CRLF - Carriage return line feed (CRLF) is a control character that originally referred to moving the carriage on typewriters back to the starting position. In computing, it’s used in classic Mac OS and some Windows-based systems to mark the end of a line. If your input uses \r as the line-ending character, you can set the delimiter to \r to correctly separate values. For example: 100\r200\r300

Example

Suppose you want to get the sum of a series of numbers in your input strings. They are separated by commas (,). To do it:

In your Pipeline, open the required Action configuration and select the input Field.
In the Operation field, choose Sum Operation.
Set Delimiter to Comma.
Give your Output field a name and click Save. You'll get the sum of the numbers in your input data. For example:

10, 5, 2 -> 17

You can try out operations with specific values using the Input field above the operation. You can enter the value in the example above and check the result in the Output field.

Code tidy

JSON Minify

Description

This operation compresses JSON data by removing unnecessary whitespace, line breaks, and formatting while retaining the full structure and functionality of the JSON. It is handy for reducing the size of JSON files or strings when storage or transfer efficiency is required.

Data types

These are the input/output expected data types for this operation:

Input data

- Strings representing the JSON data you want to optimize.

Output data

- Optimized versions of the JSON data in your input strings.

Example

Suppose you want to minify the JSON data in your input strings. To do it:

In your Pipeline, open the required Action configuration and select the input Field.
In the Operation field, choose Json Minify.
Give your Output field a name and click Save. Your JSON data will be optimized and formatted properly.

For example, the following JSON:

{
    "name": "John Doe",
    "age": 30,
    "isActive": true,
    "address": {
        "city": "New York",
        "zip": "10001"
    }
}

will be formatted like this:

{"name":"John Doe","age":30,"isActive":true,"address":{"city":"New York","zip":"10001"}}

You can try out operations with specific values using the Input field above the operation. You can enter the value in the example above and check the result in the Output field.

Control characters

Escape String

Description

This operation is used to encode or "escape" characters in a string so that they can be safely used in different contexts, such as URLs, JSON, HTML, or code. This operation is helpful when you need to format text with special characters in a way that won’t break syntax or cause unintended effects in various data formats.

Data types

These are the input/output expected data types for this operation:

Input data

- Strings with the characters you want to escape.

Output data

- Strings with the required escaped characters.

Parameters

These are the parameters you need to configure to use this operation (mandatory parameters are marked with a *):

Escape Level*

Choose how to control the extent of character escaping applied to the input. Enter one of the following:

Special chars - Escapes only a specific set of characters that have special meanings in the chosen format.
Everything - Escapes all characters that could potentially have any impact in the selected format, including less common or optional characters.
Minimal - Escapes the least amount of characters necessary to make the string safe for the specific format.

Escape Quote*

This parameter lets you specify how to handle quote characters (" and ') within the input text. Enter one of the following:

Single - Escapes only single quotes (') in the input.
Double - Escapes only double quotes (") in the input.
Backtick - Escapes only backticks (`) in the input.

JSON compatible

Set this parameter to true if you need to use the output string in a JSON. This ensures that any characters with special meanings in JSON are escaped properly, allowing the resulting string to be safely embedded in JSON objects or arrays.

Example

Suppose you want to escape characters that are between " in a series of input strings. To do it:

In the Operation field, choose Escape String.
Set Escape Level to Special chars.
Set Escape Quote to ".
Set JSON compatible to false.
Give your Output field a name and click Save. Matching characters will be escaped. For example:

You can try out operations with specific values using the Input field above the operation. You can enter the value in the example above and check the result in the Output field.

Unescape String

Description

This operation is used to decode escape sequences in a string back to their original characters. Escaped strings are often used in programming, web development, or data transmission to represent special characters that cannot be directly included in text.

Data types

These are the input/output expected data types for this operation:

Input data

- String with escape characters.

Output data

- Resulting unescaped string.

Example

Suppose you want to unescape characters in a series of input strings. To do it:

In your Pipeline, open the required configuration and select the input Field.
In the Operation field, choose Unescape string.
Give your Output field a name and click Save. All the escape characters will be removed. For example:

You can try out operations with specific values using the Input field above the operation. You can enter the value in the example above and check the result in the Output field.

Conversion

Convert Area

Description

This operation converts values from one unit of measurement to another, such as square feet, acres, square meters, and even smaller or less common units used in physics (like barns or nanobarns).

Data types

These are the input/output expected data types for this operation:

Input data

- Values whose unit of measurement you want to transform. They must be strings representing numbers.

Output data

- Resulting values after transforming them to the selected unit of measurement.

Parameters

These are the parameters you need to configure to use this operation (mandatory parameters are marked with a *):

Input units*

Enter the unit of measurement of your input data. You must indicate one of the following:

Metric

Square metre (sq m)
Square kilometre (sq km)
Centiare (ca)
Deciare (da)
Are (a)
Decare (daa)
Hectare (ha)

Imperial

Square inch (sq in)
Square foot (sq ft)
Square yard (sq yd)
Square mile (sq mi)
Perch (sq per)
Rood (ro)
International acre (ac)

US customary units

US survey acre (ac)
US survey square mile (sq mi)
US survey township

Nuclear physics

Yoctobarn (yb)
Zeptobarn (zb)
Attobarn (ab)
Femtobarn (fb)
Picobarn (pb)
Nanobarn (nb)
Microbarn (μb)
Millibarn (mb)
Barn (b)
Kilobarn (kb)
Megabarn (Mb)
Outhouse
Shed
Planck area

Comparisons

Washington D.C.
Isle of Wight
Wales
Texas

Output units*

Enter the required unit of measurement of your output data. You must indicate one of the following:

Metric

Square metre (sq m)
Square kilometre (sq km)
Centiare (ca)
Deciare (da)
Are (a)
Decare (daa)
Hectare (ha)

Imperial

Square inch (sq in)
Square foot (sq ft)
Square yard (sq yd)
Square mile (sq mi)
Perch (sq per)
Rood (ro)
International acre (ac)

US customary units

US survey acre (ac)
US survey square mile (sq mi)
US survey township

Nuclear physics

Yoctobarn (yb)
Zeptobarn (zb)
Attobarn (ab)
Femtobarn (fb)
Picobarn (pb)
Nanobarn (nb)
Microbarn (μb)
Millibarn (mb)
Barn (b)
Kilobarn (kb)
Megabarn (Mb)
Outhouse
Shed
Planck area

Comparisons

Washington D.C.
Isle of Wight
Wales
Texas

Example

Suppose you want to convert a series of events from square feet into square meters:

In your Pipeline, open the required Action configuration and select the input Field.
In the Operation field, choose Convert area.
Set Input units to Square foot (sq ft).
Set Output units to Square metre (sq m).
Give your Output field a name and click Save. The values in your input field will be transformed. For example:

5000 Square foot (sq ft) -> 464.5152 Square metre (sq m)

You can try out operations with specific values using the Input field above the operation. You can enter the value in the example above and check the result in the Output field.

Convert Data Units

Description

This operation converts values between different units of digital data, such as bits, bytes, kilobytes, megabytes, and so on. It’s especially useful when you’re dealing with data storage or transfer rates, and you need to switch between binary (base 2) and decimal (base 10) units.

Data types

These are the input/output expected data types for this operation:

Input data

- Values whose unit of data you want to transform. They must be strings representing numbers.

Output data

- Resulting values after transforming them to the selected unit of data.

Parameters

These are the parameters you need to configure to use this operation (mandatory parameters are marked with a *):

Input units*

Enter the unit of your input data. You must indicate one of the following:

Bits (b)
Nibbles
Octets
Bytes (B)

Binary bits (2^n)

Kibibits (Kib)
Mebibits (Mib)
Gibibits (Gib)
Tebibits (Tib)
Pebibits (Pib)
Exbibits (Eib)
Zebibits (Zib)
Yobibits (Yib)

Decimal bits (10^n)

Decabits
Hectobits
Kilobits (Kb)
Megabits (Mb)
Gigabits (Gb)
Terabits (Tb)
Petabits (Pb)
Exabits (Eb)
Zettabits (Zb)
Yottabits (Yb)

Binary bytes (8 x 2^n)

Kibibytes (KiB)
Mebibytes (MiB)
Gibibytes (GiB)
Tebibytes (TiB)
Pebibytes (PiB)
Exbibytes (EiB)
Zebibytes (ZiB)
Yobibytes (YiB)

Decimal bytes (8 x 10^n)

Kilobytes (KB)
Megabytes (MB)
Gigabytes (GB)
Terabytes (TB)
Petabytes (PB)
Exabytes (EB)
Zettabytes (ZB)
Yottabytes (YB)

Output units*

Enter the required unit of your output data. You must indicate one of the following:

Bits (b)
Nibbles
Octets
Bytes (B)

Binary bits (2^n)

Kibibits (Kib)
Mebibits (Mib)
Gibibits (Gib)
Tebibits (Tib)
Pebibits (Pib)
Exbibits (Eib)
Zebibits (Zib)
Yobibits (Yib)

Decimal bits (10^n)

Decabits
Hectobits
Kilobits (Kb)
Megabits (Mb)
Gigabits (Gb)
Terabits (Tb)
Petabits (Pb)
Exabits (Eb)
Zettabits (Zb)
Yottabits (Yb)

Binary bytes (8 x 2^n)

Kibibytes (KiB)
Mebibytes (MiB)
Gibibytes (GiB)
Tebibytes (TiB)
Pebibytes (PiB)
Exbibytes (EiB)
Zebibytes (ZiB)
Yobibytes (YiB)

Decimal bytes (8 x 10^n)

Kilobytes (KB)
Megabytes (MB)
Gigabytes (GB)
Terabytes (TB)
Petabytes (PB)
Exabytes (EB)
Zettabytes (ZB)
Yottabytes (YB)

Example

Suppose you want to convert a series of events from megabits into kilobytes:

In your Pipeline, open the required Action configuration and select the input Field.
In the Operation field, choose Convert data units.
Set Input units to Megabits (Mb).
Set Output units to Kilobytes (KB).
Give your Output field a name and click Save. The data type of the values in your input field will be transformed. For example:

2 Megabits (Mb) -> 250 Kilobytes (KB)

You can try out operations with specific values using the Input field above the operation. You can enter the value in the example above and check the result in the Output field.

Convert Distance

Description

This operation converts values between different units of length or distance.

Data types

These are the input/output expected data types for this operation:

Input data

- Values whose unit of length you want to transform. They must be strings representing numbers.

Output data

- Resulting values after transforming them to the selected unit of length.

Parameters

These are the parameters you need to configure to use this operation (mandatory parameters are marked with a *):

Input units*

Enter the unit of length of your input data. You must indicate one of the following:

Metric

Nanometres (nm)
Micrometres (μm)
Millimetres (mm)
Centimetres (cm)
Metres (m)
Kilometres (km)

Imperial

Thou (th)
Inches (in)
Feet (ft)
Yards (yd)
Chains (ch)
Furlongs (fur)
Miles (mi)
Leagues (lea)

Maritime

Fathoms (ftm)
Cables
Nautical miles

Comparisons

Cars (4m)
Buses (8.4m)
American football fields (91m)
Football pitches (105m)

Astronomical

Earth-to-Moons
Earth's equators
Astronomical units (au)
Light-years (ly)
Parsecs (pc)

Output units*

Enter the required unit of length of your output data. You must indicate one of the following:

Metric

Nanometres (nm)
Micrometres (μm)
Millimetres (mm)
Centimetres (cm)
Metres (m)
Kilometres (km)

Imperial

Thou (th)
Inches (in)
Feet (ft)
Yards (yd)
Chains (ch)
Furlongs (fur)
Miles (mi)
Leagues (lea)

Maritime

Fathoms (ftm)
Cables
Nautical miles

Comparisons

Cars (4m)
Buses (8.4m)
American football fields (91m)
Football pitches (105m)

Astronomical

Earth-to-Moons
Earth's equators
Astronomical units (au)
Light-years (ly)
Parsecs (pc)

Example

Suppose you want to convert a series of events from meters into yards:

In your Pipeline, open the required Action configuration and select the input Field.
In the Operation field, choose Convert distance.
Set Input units to Metres (m).
Set Output units to Yards (yd).
Give your Output field a name and click Save. The unit of length of the values in your input field will be transformed. For example:

100 Metres (m) -> 109.3613298 Yards (yd)

You can try out operations with specific values using the Input field above the operation. You can enter the value in the example above and check the result in the Output field.

Convert Mass

Description

This operation converts values between different units of mass.

Data types

These are the input/output expected data types for this operation:

Input data

- Values whose unit of mass you want to transform. They must be strings representing numbers.

Output data

- Resulting values after transforming them to the selected unit of mass.

Parameters

These are the parameters you need to configure to use this operation (mandatory parameters are marked with a *):

Input units*

Enter the unit of mass of your input data. You must indicate one of the following:

Metric

Yoctogram (yg)
Zeptogram (zg)
Attogram (ag)
Femtogram (fg)
Picogram (pg)
Nanogram (ng)
Microgram (μg)
Milligram (mg)
Centigram (cg)
Decigram (dg)
Gram (g)
Decagram (dag)
Hectogram (hg)
Kilogram (kg)
Megagram (Mg)
Tonne (t)
Gigagram (Gg)
Teragram (Tg)
Petagram (Pg)
Exagram (Eg)
Zettagram (Zg)
Yottagram (Yg)

Imperial Avoirdupois

Grain (gr)
Dram (dr)
Ounce (oz)
Pound (lb)
Nail
Stone (st)
Quarter (qr)
Tod
US hundredweight (cwt)
Imperial hundredweight (cwt)
US ton (t)
Imperial ton (t)

Imperial Troy

Grain (gr)
Pennyweight (dwt)
Troy dram (dr t)
Troy ounce (oz t)
Troy pound (lb t)
Mark

Archaic

Wey
Wool wey
Suffolk wey
Wool sack
Coal sack
Load
Last
Flax or feather last
Gunpowder last
Picul
Rice last

Comparisons

Big Ben (14 tonnes)
Blue whale (180 tonnes)
International Space Station (417 tonnes)
Space Shuttle (2,041 tonnes)
RMS Titanic (52,000 tonnes)
Great Pyramid of Giza (6,000,000 tonnes)
Earth's oceans (1.4 yottagrams)

Astronomical

A teaspoon of neutron star (5,500 million tonnes)
Lunar mass (ML)
Earth mass (M⊕)
Jupiter mass (MJ)
Solar mass (M☉)
Sagittarius A* (7.5 x 10^36 kgs-ish)
Milky Way galaxy (1.2 x 10^42 kgs)
The observable universe (1.45 x 10^53 kgs)

Output units*

Enter the required unit of mass of your output data. You must indicate one of the following:

Metric

Yoctogram (yg)
Zeptogram (zg)
Attogram (ag)
Femtogram (fg)
Picogram (pg)
Nanogram (ng)
Microgram (μg)
Milligram (mg)
Centigram (cg)
Decigram (dg)
Gram (g)
Decagram (dag)
Hectogram (hg)
Kilogram (kg)
Megagram (Mg)
Tonne (t)
Gigagram (Gg)
Teragram (Tg)
Petagram (Pg)
Exagram (Eg)
Zettagram (Zg)
Yottagram (Yg)

Imperial Avoirdupois

Grain (gr)
Dram (dr)
Ounce (oz)
Pound (lb)
Nail
Stone (st)
Quarter (qr)
Tod
US hundredweight (cwt)
Imperial hundredweight (cwt)
US ton (t)
Imperial ton (t)

Imperial Troy

Grain (gr)
Pennyweight (dwt)
Troy dram (dr t)
Troy ounce (oz t)
Troy pound (lb t)
Mark

Archaic

Wey
Wool wey
Suffolk wey
Wool sack
Coal sack
Load
Last
Flax or feather last
Gunpowder last
Picul
Rice last

Comparisons

Big Ben (14 tonnes)
Blue whale (180 tonnes)
International Space Station (417 tonnes)
Space Shuttle (2,041 tonnes)
RMS Titanic (52,000 tonnes)
Great Pyramid of Giza (6,000,000 tonnes)
Earth's oceans (1.4 yottagrams)

Astronomical

A teaspoon of neutron star (5,500 million tonnes)
Lunar mass (ML)
Earth mass (M⊕)
Jupiter mass (MJ)
Solar mass (M☉)
Sagittarius A* (7.5 x 10^36 kgs-ish)
Milky Way galaxy (1.2 x 10^42 kgs)
The observable universe (1.45 x 10^53 kgs)

Example

Suppose you want to convert a series of events from kilograms into pounds:

In your Pipeline, open the required Action configuration and select the input Field.
In the Operation field, choose Convert mass.
Set Input units to Kilogram (kg).
Set Output units to Pound (lb).
Give your Output field a name and click Save. The unit of mass of the values in your input field will be transformed. For example:

100 Kilogram (kg) -> 220.4622622 Pound (lb)

You can try out operations with specific values using the Input field above the operation. You can enter the value in the example above and check the result in the Output field.

Convert Speed

Description

This operation converts values between different units of speed.

Data types

These are the input/output expected data types for this operation:

Input data

- Values whose unit of speed you want to transform. They must be strings representing numbers.

Output data

- Resulting values after transforming them to the selected unit of speed.

Parameters

These are the parameters you need to configure to use this operation (mandatory parameters are marked with a *):

Input units*

Enter the unit of speed of your input data. You must indicate one of the following:

Metric

Metres per second (m/s)
Kilometres per hour (km/h)

Imperial

Miles per hour (mph)
Knots (kn)

Comparisons

Human hair growth rate
Bamboo growth rate
World's fastest snail
Usain Bolt's top speed
Jet airliner cruising speed
Concorde
SR-71 Blackbird
Space Shuttle
International Space Station

Scientific

Sound in standard atmosphere
Sound in water
Lunar escape velocity
Earth escape velocity
Earth's solar orbit
Solar system's Milky Way orbit
Milky Way relative to the cosmic microwave background
Solar escape velocity
Neutron star escape velocity (0.3c)
Light in a diamond (0.4136c)
Signal in an optical fibre (0.667c)
Light (c)

Output units*

Enter the required unit of speed of your output data. You must indicate one of the following:

Metric

Metres per second (m/s)
Kilometres per hour (km/h)

Imperial

Miles per hour (mph)
Knots (kn)

Comparisons

Human hair growth rate
Bamboo growth rate
World's fastest snail
Usain Bolt's top speed
Jet airliner cruising speed
Concorde
SR-71 Blackbird
Space Shuttle
International Space Station

Scientific

Sound in standard atmosphere
Sound in water
Lunar escape velocity
Earth escape velocity
Earth's solar orbit
Solar system's Milky Way orbit
Milky Way relative to the cosmic microwave background
Solar escape velocity
Neutron star escape velocity (0.3c)
Light in a diamond (0.4136c)
Signal in an optical fibre (0.667c)
Light (c)

Example

Suppose you want to convert a series of events from kilometers per hour into miles per hour:

In your Pipeline, open the required Action configuration and select the input Field.
In the Operation field, choose Convert speed.
Set Input units to Kilometres per hour (km/h).
Set Output units to Miles per hour (mph).
Give your Output field a name and click Save. The unit of speed of the values in your input field will be transformed. For example:

200 Kilometres per hour (km/h) -> 124.2841804 Miles per hour (mph)

You can try out operations with specific values using the Input field above the operation. You can enter the value in the example above and check the result in the Output field.

Data format

From Base64

Description

This operation is used to decode data from a Base64 string back into its raw format. Base64 is a binary-to-text encoding method commonly used to encode binary data (like images or files) into text that can be easily transmitted over text-based protocols such as email, JSON, or XML. It’s also used for data storage, ensuring the data remains ASCII-safe.

Data types

These are the input/output expected data types for this operation:

Input data

- The Base64 strings you want to decode.

Output data

- Decoded strings.

Parameters

These are the parameters you need to configure to use this operation (mandatory parameters are marked with a *):

Strict Mode

Set this option to true to include additional checks and ensure the input is correctly formatted as Base64. Enabling Strict Mode can be useful to catch any errors or irregularities in the Base64-encoded input, preventing potential issues in decoding or data processing.

Example

Suppose you want to decode a series of events in the Base64 encoding scheme:

In your Pipeline, open the required Action configuration and select the input Field.
In the Operation field, choose From Base64.
Set Strict Mode to true.
Give your Output field a name and click Save. The values in your input field will be decoded. For example:

SGVsbG8sIE9udW0h -> Hello, Onum!

You can try out operations with specific values using the Input field above the operation. You can enter the value in the example above and check the result in the Output field.

From Hex

Description

This operation is used to convert hexadecimal-encoded data back into its original form, whether it’s plain text, binary data, or another format. Hexadecimal encoding is often used to represent binary data in a readable, ASCII-compatible format.

Data types

These are the input/output expected data types for this operation:

Input data

- The hexadecimal-encoded data you want to decode.

Output data

- Decoded string.

Parameters

These are the parameters you need to configure to use this operation (mandatory parameters are marked with a *):

Delimiter

Specify a delimiter if your hex data is separated by spaces, commas, or another character. Choose between:

Auto - Automatically detects the formatting of the hexadecimal data, making it a versatile choice when the exact format isn’t known or when the data is inconsistently formatted.
Space - Assumes that each byte (two hex characters) is separated by a single space.
Percent - Assumes that each hex byte is separated by a percent sign (%)
Comma - Assumes that each hex byte is separated by a comma (,)
Semi-colon - Assumes that each hex byte is separated by a semi-colon (;)
Colon - Assumes that each hex byte is separated by a colon (:)
Line feed - Assumes that each byte is on a new line, separated by line breaks.
CRLF - Setting the delimiter to CRLF (\r\n) will place a CRLF sequence after each hex byte or hex pair in the output.
0x - Assumes that each hexadecimal byte or value in the input starts with the 0x prefix. The operation will ignore the 0x part and treat the following characters as hexadecimal data.
0x with comma - This option is similar to the 0x option but also expects each hex value to be separated by a comma. Each value in the input should be prefixed by 0x and separated from the next by a comma.
\x - Interprets hexadecimal data prefixed by \x in each hex pair. This format is commonly found in programming and scripting languages (like JavaScript, C, or Python) where \x is used to denote hexadecimal byte values.
None - This option assumes that the hexadecimal data is a continuous string without any separators between each byte.

Example

Suppose you want to decode a series of events including hexadecimal-encoded data:

In your Pipeline, open the required Action configuration and select the input Field.
In the Operation field, choose From Hex.
Set Delimiter to Space.
Give your Output field a name and click Save. The values in your input field will be decoded. For example:

48 65 6c 6c 6f 20 57 6f 72 6c 64 -> Hello World

You can try out operations with specific values using the Input field above the operation. You can enter the value in the example above and check the result in the Output field.

To Base64

Description

This operation is used to encode data into a Base64 string. Base64 is a binary-to-text encoding method commonly used to encode binary data (like images or files) into text that can be easily transmitted over text-based protocols such as email, JSON, or XML. It’s also used for data storage, ensuring the data remains ASCII-safe.

Data types

These are the input/output expected data types for this operation:

Input data

- The string you want to encode.

Output data

- Resulting Base64 string.

Example

Suppose you want to encode a series of events into Base64:

In your Pipeline, open the required configuration and select the input Field.
In the Operation field, choose To Base64.
Give your Output field a name and click Save. The values in your input field will be encoded. For example:

You can try out operations with specific values using the Input field above the operation. You can enter the value in the example above and check the result in the Output field.

To Hex

Description

This operation is used to convert a string to a hexadecimal code. Hexadecimal encoding is often used to represent binary data in a readable, ASCII-compatible format.

Data types

These are the input/output expected data types for this operation:

Input data

- Strings you want to encode.

Output data

- Resulting hexadecimal codes.

Parameters

These are the parameters you need to configure to use this operation (mandatory parameters are marked with a *):

Delimiter

Specify how you want to delimit the bytes of your hexadecimal codes. Choose between:

Auto - Automatically detects the formatting of the hexadecimal data, making it a versatile choice when the exact format isn’t known or when the data is inconsistently formatted.
Space - Assumes that each byte (two hex characters) is separated by a single space.
Percent - Assumes that each hex byte is separated by a percent sign (%)
Comma - Assumes that each hex byte is separated by a comma (,)
Semi-colon - Assumes that each hex byte is separated by a semi-colon (;)
Colon - Assumes that each hex byte is separated by a colon (:)
Line feed - Assumes that each byte is on a new line, separated by line breaks.
CRLF - Setting the delimiter to CRLF (\r\n) will place a CRLF sequence after each hex byte or hex pair in the output.
0x - Assumes that each hexadecimal byte or value in the input starts with the 0x prefix. The operation will ignore the 0x part and treat the following characters as hexadecimal data.
0x with comma - This option is similar to the 0x option but also expects each hex value to be separated by a comma. Each value in the input should be prefixed by 0x and separated from the next by a comma.
\x - Interprets hexadecimal data prefixed by \x in each hex pair. This format is commonly found in programming and scripting languages (like JavaScript, C, or Python) where \x is used to denote hexadecimal byte values.
None - This option assumes that the hexadecimal data is a continuous string without any separators between each byte.

Example

Suppose you want to encode a series of events into hexadecimal-encoded data:

In the Operation field, choose To Hex.
Set Delimiter to Space.
Give your Output field a name and click Save. The values in your input field will be encoded. For example:

You can try out operations with specific values using the Input field above the operation. You can enter the value in the example above and check the result in the Output field.

Date / Time

From Unix Timestamp

Description

This operation converts Unix timestamps into human-readable date and time formats. Unix timestamps represent the number of seconds (or milliseconds) that have elapsed since the Unix epoch, which began at 00:00:00 UTC on January 1, 1970.

Data types

These are the input/output expected data types for this operation:

Input data

- Integer values representing the Unix timestamps to be converted.

Output data

- A string representing the formatted time.

Parameters

These are the parameters you need to configure to use this operation (mandatory parameters are marked with a *):

Time Unit*

Specify the unit of time represented by the input timestamp. Choose one of the following:

Seconds
Milliseconds
Microseconds
Nanoseconds

Timezone Output

Specify the timezone of the input date strings. Enter one of the following:

UTC
GMT
PST
PDT
CET
CEST
Any IANA time zone

If not provided, the default value is UTC.

Format Output*

Specify the desired format of your output date strings.

Note that the reference date that you must use for both the Input Format and Output Format parameters is the following:

Date - January 02, 2006
Time - 15:04:05

Following the example in the Input Format parameter, imagine you have this input date 2024-10-24T14:11:13Z and set the Input Timezone to UTC+1.

If you enter the following in the Output Format parameter:

02/01/2006 15:04:05

and set Output Timezone to UTC+8, you will get this as your output date:

24/10/2024 21:11:13

The following formats are supported for both the Input Format and Output Format parameters:

RFC3339 (for example 2006-01-02T15:04:05Z)
ANSIC (for example Mon Jan 2 15:04:05 2006)
UnixDate (for example Mon Jan 2 15:04:05 PST 2006)
Custom format (for example 02-01-2006 15:04:05)

Example

Suppose you want to convert a series of timestamps into human-readable date strings:

In your Pipeline, open the required Action configuration and select the input Field.
In the Operation field, choose From Unix Timestamp.
Set Time Unit to Seconds.
Set Timezone Output to UTC.
Set Format Output to Mon 2 January 2006 15:04:05 UTC
Give your Output field a name and click Save. The values in your input field will be transformed. For example:

978346800 -> Mon 1 January 2001 11:00:00 UTC

You can try out operations with specific values using the Input field above the operation. You can enter the value in the example above and check the result in the Output field.

To Timestamp

Description

This operation converts strings representing a date into a RFC 3339 timestamp.

Data types

These are the input/output expected data types for this operation:

Input data

- Strings representing the dates you want to transform in the format specified.

Output data

- Resulting RFC 3339 timestamps.

Parameters

These are the parameters you need to configure to use this operation (mandatory parameters are marked with a *):

Format*

Specify the date format of the input strings. Enter one of the following:

RFC3339 - For example: 2006-01-02T15:04:05Z
DateOnly - For example: 2006-01-02
TimeOnly - For example: 15:04:05
DateTime - For example: 2006-01-02 15:04:05
UnixDate - For example: Mon Jan 2 15:04:05 MST 2006
Epoch - For example: 1732114401
EpochMillis - For example: 1732114472803
EpochMicros - For example: 173211447280386
EpochNanos - For example: 17321144728038690

Example

Suppose you want to convert a series of strings into timestamps:

In the Operation field, choose To Timestamp.
Set Format to DateOnly.
Give your Output field a name and click Save. The values in your input field will be transformed. For example:

You can try out operations with specific values using the Input field above the operation. You can enter the value in the example above and check the result in the Output field.

To Unix Timestamp

Description

This operation converts a date and time into a Unix timestamp. A Unix timestamp is the number of seconds (or milliseconds) that have elapsed since January 1, 1970, 00:00:00 UTC (commonly referred to as the "Epoch").

Data types

These are the input/output expected data types for this operation:

Input data

- Strings representing the dates you want to transform.

Output data

- Integers representing the resulting Unix timestamps.

Parameters

These are the parameters you need to configure to use this operation (mandatory parameters are marked with a *):

Unit*

Specify the unit of time of the output timestamp. Choose one of the following:

Seconds
Milliseconds
Microseconds
Nanoseconds

Example

Suppose you want to convert a series of dates into Unix timestamps:

In the Operation field, choose To Unix Timestamp.
Set Time Unit to Seconds.
Give your Output field a name and click Save. The values in your input field will be transformed. For example:

You can try out operations with specific values using the Input field above the operation. You can enter the value in the example above and check the result in the Output field.

Translate Datetime Format

Description

This operation allows you to convert dates and times from one format to another. This is useful for standardizing timestamps, converting between systems with different date/time formats, or simply making a date more readable.

Data types

These are the input/output expected data types for this operation:

Input data

- Strings representing the dates you want to convert.

Output data

- Output formatted date strings.

Parameters

These are the parameters you need to configure to use this operation (mandatory parameters are marked with a *):

Input Format*

Specify the format of your input date strings.

Note that the reference date that you must use for both the Input Format and Output Format parameters is the following:

Date - January 02, 2006
Time - 15:04:05

That means you must specify the format of your input dates using the date and time above. For example, for the following input date:

2024-10-24T14:11:13Z

you must specify the format as follows:

2006-01-02T15:04:05Z

The following formats are supported for both the Input Format and Output Format parameters:

RFC3339 (for example 2006-01-02T15:04:05Z)
ANSIC (for example Mon Jan 2 15:04:05 2006)
UnixDate (for example Mon Jan 2 15:04:05 PST 2006)
Custom format (for example 02-01-2006 15:04:05)

Input Timezone*

Specify the timezone of the input date strings. Enter one of the following:

UTC
GMT
PST
PDT
CET
CEST
Any IANA time zone

Output Format*

Specify the desired format of your output date strings.

Note that the reference date that you must use for both the Input Format and Output Format parameters is the following:

Date - January 02, 2006
Time - 15:04:05

Following the example in the Input Format parameter, imagine you have this input date 2024-10-24T14:11:13Z and set the Input Timezone to UTC+1.

If you enter the following in the Output Format parameter:

02/01/2006 15:04:05

and set Output Timezone to UTC+8, you will get this as your output date:

24/10/2024 21:11:13

The following formats are supported for both the Input Format and Output Format parameters:

RFC3339 (for example 2006-01-02T15:04:05Z)
ANSIC (for example Mon Jan 2 15:04:05 2006)
UnixDate (for example Mon Jan 2 15:04:05 PST 2006)
Custom format (for example 02-01-2006 15:04:05)

Output Timezone*

Specify the timezone of the output date strings. Enter one of the following:

UTC
GMT
PST
PDT
CET
CEST
Any IANA time zone

Example

Suppose you want to convert a series of dates in the following format:

MM-DD-YYYY HH:mm:ss

into this one:

ddd, D MMM YYYY HH:mm:ss ZZ

In your Pipeline, open the required Action configuration and select the input Field.
In the Operation field, choose Translate Datetime Format.
Set Input Format to 01-02-2006 15:04:05
Set Input Timezone to UTC+1
Set Output Format to Mon, 2 Jan 2006 15:04:05 +0000
Set Output Timezone to UTC+1
Give your Output field a name and click Save. The format of the dates in your input field will be transformed. For example:

05-20-2023 10:10:45 -> Sat, 20 May 2023 10:10:45 +0000

You can try out operations with specific values using the Input field above the operation. You can enter the value in the example above and check the result in the Output field.

Encryption / Encoding

JWT Decode

Description

This operation is used to decode JSON Web Tokens (JWTs). JWTs are commonly used for authentication and data exchange in web applications, and they consist of three parts:

Header - Encoded metadata about the token.
Payload - Encoded claims or data being transmitted.
Signature - A cryptographic signature to verify the token’s integrity.

This operation helps decode and inspect the header and payload of a JWT without verifying the signature.

Data types

These are the input/output expected data types for this operation:

Input data

- JWT string you want to decode.

Output data

- Decoded JWT strings

Example

Suppose you want to decode a series of events in the Base64 encoding scheme:

In the Operation field, choose JWT Decode.
Give your Output field a name and click Save. The values in your input field will be decoded.

For example, the following JWT:

will be decoded as:

You can try out operations with specific values using the Input field above the operation. You can enter the value in the example above and check the result in the Output field.

File system permissions

Encode URI

Description

This operation is used to break down and analyze a Uniform Resource Identifier (URI) into its individual components, making it easier to understand and work with the data in a URI.

Data types

These are the input/output expected data types for this operation:

Input data

- URLs you want to analyze.

Output data

- Breakdown of the input URLs.

Example

Suppose you want to analyze a series of URLs in your input data:

In your Pipeline, open the required Action configuration and select the input Field.
In the Operation field, choose Encode URI.
Give your Output field a name and click Save. The URLs in your input field will be analyzed.

For example, for the following URL:

https://user:pass@example.com:8080/path/to/resource?key=value#fragment

you will get the following analysis:

Scheme: https Host: example.com:8080 Path: /path/to/resource Arguments: map[key:[value]] User: user Password: pass

You can try out operations with specific values using the Input field above the operation. You can enter the value in the example above and check the result in the Output field.

Parse UNIX file permissions

Description

This operation is used to interpret and analyze standard UNIX file permission strings (e.g., -rwxr-xr--) and provide a detailed breakdown of the permissions, including their binary and octal representations. You can also enter the code formats to get the UNIX file permission strings.

Data types

These are the input/output expected data types for this operation:

Input data

- UNIX-style file permission strings or codes you want to analyze.

Output data

- Details of the provided UNIX file permission strings/codes.

Example

Suppose you want to analyze a series of UNIX file permission strings in your input data:

In your Pipeline, open the required Action configuration and select the input Field.
In the Operation field, choose Parse UNIX file permissions.
Give your Output field a name and click Save. The values in your input field will be decoded.

For example, for the following UNIX file permission string:

-rwxr-xr--

you'll get the following breakdown:

Textual representation: -rwxr-xr-- Octal representation: 0754 +---------+-------+-------+-------+ | | User | Group | Other | +---------+-------+-------+-------+ | Read | X | X | X | +---------+-------+-------+-------+ | Write | X | | | +---------+-------+-------+-------+ | Execute | X | X | | +---------+-------+-------+-------+

You can try out operations with specific values using the Input field above the operation. You can enter the value in the example above and check the result in the Output field.

Format conversion

CSV to JSON

Description

This operation converts a CSV file to JSON format.

Data types

These are the input/output expected data types for this operation:

Input data

- CSV-formatted strings you want to transform into JSON.

Output data

- Resulting JSON-formatted strings.

Parameters

These are the parameters you need to configure to use this operation (mandatory parameters are marked with a *):

Cell delimiter*

This setting defines the character used to separate cells (or columns) in each row.

Format*

Format of the resulting JSON. Choose between:

Array of dictionaries - Each row in the CSV is converted into an object (similar to a dictionary) with key-value pairs where the keys are column headers.
Array of arrays - Each row in the CSV is converted into a JSON array, with values only and no keys (useful if you don’t need named fields).

Example

Suppose you want to convert a series of events in CSV format into JSON:

In your Pipeline, open the required Action configuration and select the input Field.
In the Operation field, choose CSV to JSON.
Set Cell delimiter to , (comma).
Set Format to Array of dictionaries.
Give your Output field a name and click Save. The CSV strings in your input field will be transformed into JSON.

For example, the following CSV:

First name,Last name,Age,City
John,Wick,20,New-York
Tony,Stark,30,Madrid

will be transformed into this JSON:

[
  {
    "First name": "John",
    "Last name": "Wick",
    "Age": "20",
    "City": "New-York"
  },
  {
    "First name": "Tony",
    "Last name": "Stark",
    "Age": "30",
    "City": "Madrid"
  }
]

You can try out operations with specific values using the Input field above the operation. You can enter the value in the example above and check the result in the Output field.

JSON to CSV

Description

This operation converts JSON data into a CSV file.

Data types

These are the input/output expected data types for this operation:

Input data

- JSON data you want to transform into CSV. They must be strings formatted as JSON data.

Output data

- Resulting CSV files.

Parameters

These are the parameters you need to configure to use this operation (mandatory parameters are marked with a *):

Cell delimiter*

This setting defines the character used to separate cells (or columns) in the resulting CSV

Row delimiter*

This setting defines the character used to separate rows in the resulting CSV.

Example

Suppose you want to convert a series of events in JSON format into CSV:

In your Pipeline, open the required Action configuration and select the input Field.
In the Operation field, choose JSON to CSV.
Set Cell delimiter to , (comma).
Set Row delimiter to \n (new line)
Give your Output field a name and click Save. The JSON-formatted strings in your input field will be transformed into CSV.

For example, the following JSON:

[
  {
    "First name": "John",
    "Last name": "Wick",
    "Age": "20",
    "City": "New-York"
  },
  {
    "First name": "Tony",
    "Last name": "Stark",
    "Age": "30",
    "City": "Madrid"
  }
]

will be transformed into this CSV:

First name,Last name,Age,City       
John,Wick,20,New-York
Tony,Stark,30,Madrid

You can try out operations with specific values using the Input field above the operation. You can enter the value in the example above and check the result in the Output field.

Hashing

Keccak

Description

This operation allows you to hash data using the Keccak cryptographic hash algorithm. Keccak is the original algorithm that was standardized as SHA-3 by the National Institute of Standards and Technology (NIST). It is widely used in cryptographic applications, such as blockchain technologies (e.g., Ethereum).

Data types

These are the input/output expected data types for this operation:

Input data

- Data you want to hash. This could be text, binary, or hexadecimal data.

Output data

- Keccak hash value in hexadecimal format.

Parameters

These are the parameters you need to configure to use this operation (mandatory parameters are marked with a *):

Size*

Choose the desired bit size of the hash output. Enter one of the following:

512
384
256
224

Example

Suppose you want to hash your input strings using the Keccak algorithm:

In your Pipeline, open the required Action configuration and select the input Field.
In the Operation field, choose Keccak.
Set Size to 256.
Give your Output field a name and click Save. The strings in your input field will be hashed using the Keccak algorithm.

For example, the following string:

Hello World!

will be hashed as:

3ea2f1d0abf3fc66cf29eebb70cbd4e7fe762ef8a09bcc06c8edf641230afec0

You can try out operations with specific values using the Input field above the operation. You can enter the value in the example above and check the result in the Output field.

MD2

Description

This operation allows you to hash data using the MD2 (Message Digest 2) algorithm. MD2 is a cryptographic hash function primarily intended for use in systems based on 8-bit computers. It produces a 128-bit hash value (16 bytes), typically represented as a 32-character hexadecimal string.

Data types

These are the input/output expected data types for this operation:

Input data

- Data you want to hash.

Output data

- MD2 hash values.

Example

Suppose you want to hash your input strings using the MD2 algorithm:

In your Pipeline, open the required configuration and select the input Field.
In the Operation field, choose MD2.
Give your Output field a name and click Save. The strings in your input field will be hashed using the MD2 algorithm.

For example, the following string:

will be hashed as:

You can try out operations with specific values using the Input field above the operation. You can enter the value in the example above and check the result in the Output field.

MD4

Description

This operation allows you to hash data using the MD4 (Message Digest 4) algorithm. MD4 is a cryptographic hash function primarily intended for use in systems based on 32-bit computers. It produces a 128-bit hash value (16 bytes), typically represented as a 32-character hexadecimal string.

Data types

These are the input/output expected data types for this operation:

Input data

- Data you want to hash.

Output data

- MD4 hash values.

Example

Suppose you want to hash your input strings using the MD4 algorithm:

In your Pipeline, open the required configuration and select the input Field.
In the Operation field, choose MD4.
Give your Output field a name and click Save. The strings in your input field will be hashed using the MD4 algorithm.

For example, the following string:

will be hashed as:

You can try out operations with specific values using the Input field above the operation. You can enter the value in the example above and check the result in the Output field.

MD5

Description

This operation allows you to hash data using the MD5 (Message Digest 5) algorithm. MD5 is a cryptographic hash function primarily intended for use in systems based on 32-bit computers. It produces a 128-bit hash value (16 bytes), typically represented as a 32-character hexadecimal string.

Data types

These are the input/output expected data types for this operation:

Input data

- Data you want to hash.

Output data

- MD5 hash values.

Example

Suppose you want to hash your input strings using the MD5 algorithm:

In your Pipeline, open the required Action configuration and select the input Field.
In the Operation field, choose MD5.
Give your Output field a name and click Save. The strings in your input field will be hashed using the MD5 algorithm.

For example, the following string:

Hello World!

will be hashed as:

d41d8cd98f00b204e9800998ecf8427e

You can try out operations with specific values using the Input field above the operation. You can enter the value in the example above and check the result in the Output field.

SHA0

Description

This operation is used to compute the SHA-0 hash of an input string. SHA-0 is a cryptographic hash function and a predecessor to the more widely known SHA-1.

Data types

These are the input/output expected data types for this operation:

Input data

- Data you want to process.

Output data

- SHA-0 hash of the input data.

Example

Suppose you want to get the SHA0 hashes a series of strings in your input data:

In your Pipeline, open the required Action configuration and select the input Field.
In the Operation field, choose SHA0.
Give your Output field a name and click Save. You'll get the SHA0 hashes of your input strings.

For example:

Hello World! -> 1261178ff9a732aacfece0d8b8bd113255a57960

You can try out operations with specific values using the Input field above the operation. You can enter the value in the example above and check the result in the Output field.

SHA1

Description

This operation is used to compute the SHA-1 hash of a given input. SHA-1 (Secure Hash Algorithm 1) is a cryptographic hash function that produces a 160-bit (20-byte) hash value, typically represented as a 40-character hexadecimal string.

Data types

These are the input/output expected data types for this operation:

Input data

- Data you want to process.

Output data

- SHA-1 hash of the input data.

Example

Suppose you want to get the SHA1 hashes a series of strings in your input data:

In your Pipeline, open the required configuration and select the input Field.
In the Operation field, choose SHA1.
Give your Output field a name and click Save. You'll get the SHA1 hashes of your input strings.

For example:

You can try out operations with specific values using the Input field above the operation. You can enter the value in the example above and check the result in the Output field.

SHA2

Description

This operation is used to compute cryptographic hashes using the SHA-2 family of hash functions. SHA-2 is a widely used and more secure successor to SHA-1.

Data types

These are the input/output expected data types for this operation:

Input data

- Data you want to process.

Output data

- SHA-2 hash of the input data.

Parameters

These are the parameters you need to configure to use this operation (mandatory parameters are marked with a *):

Size*

Choose the desired length of bits that the output hash will contain. Enter one of the following:

512
384
256
224
512/256
512/224

Example

Suppose you want to get the SHA2 hashes a series of strings in your input data:

In the Operation field, choose SHA2.
Set Size to 512.
Give your Output field a name and click Save. You'll get the SHA2 hashes of your input strings.

For example:

You can try out operations with specific values using the Input field above the operation. You can enter the value in the example above and check the result in the Output field.

SHA3

Description

This operation is used to compute cryptographic hashes using the SHA-3 family of hash functions. SHA-3 offers enhanced security and flexibility compared to its predecessors, including the SHA-2 family.

Data types

These are the input/output expected data types for this operation:

Input data

- Data you want to process.

Output data

- SHA-3 hash of the input data.

Parameters

These are the parameters you need to configure to use this operation (mandatory parameters are marked with a *):

Size*

Choose the desired length of bits that the output hash will contain. Enter one of the following:

512
384
256
224

Example

Suppose you want to get the SHA3 hashes a series of strings in your input data:

In your Pipeline, open the required Action configuration and select the input Field.
In the Operation field, choose SHA3.
Set Size to 512.
Give your Output field a name and click Save. You'll get the SHA3 hashes of your input strings.

For example:

Hello World! -> 32400b5e89822de254e8d5d94252c52bdcb27a3562ca593e980364d9848b8041b98eabe16c1a6797484941d2376864a1b0e248b0f7af8b1555a778c336a5bf48

You can try out operations with specific values using the Input field above the operation. You can enter the value in the example above and check the result in the Output field.

Shake

Description

This operation is used to compute the cryptographic hash of an input using the SHAKE (Secure Hash Algorithm with Keccak) family. SHAKE is a customizable hash function based on the Keccak sponge construction, which allows you to specify the length of the output hash.

SHAKE is part of the SHA-3 family, but it differs from other SHA-3 variants in that it is an Extendable Output Function (XOF). This means you can generate a hash of any length, rather than being restricted to fixed-length outputs like SHA3-256 or SHA3-512.

Data types

These are the input/output expected data types for this operation:

Input data

- Data you want to process.

Output data

- SHAKE hash of the input data.

Parameters

These are the parameters you need to configure to use this operation (mandatory parameters are marked with a *):

Capacity*

The capacity determines the security strength of the SHAKE function. It is a measure of how resistant the function is to various cryptographic attacks, such as collisions or preimage attacks. The higher the capacity, the stronger the security, but the slower the hashing process due to less space available for absorbing the input.

Enter one of the following:

256
128

Size*

Choose the desired length of bits that the output hash will contain.

Example

Suppose you want to get the SHAKE hashes a series of strings in your input data:

In your Pipeline, open the required Action configuration and select the input Field.
In the Operation field, choose Shake.
Set Capacity to 256.
Set Size to 512.
Give your Output field a name and click Save. You'll get the SHAKE hashes of your input strings.

For example:

Hello World! -> 35259d2903a1303d3115c669e2008510fc79acb50679b727ccb567cc3f786de3553052e47d4dd715cc705ce212a92908f4df9e653fa3653e8a7855724d366137

You can try out operations with specific values using the Input field above the operation. You can enter the value in the example above and check the result in the Output field.

SM3

Description

This operation is used to compute a cryptographic hash using the SM3 algorithm.

Data types

These are the input/output expected data types for this operation:

Input data

- Data you want to process.

Output data

- SM3 hash of the input data.

Parameters

These are the parameters you need to configure to use this operation (mandatory parameters are marked with a *):

Length*

Choose the desired length of bits that the output hash will contain. Enter one of the following:

32
64
96
128
160
192
224
256

Example

Suppose you want to get the SM3 hashes a series of strings in your input data:

In your Pipeline, open the required Action configuration and select the input Field.
In the Operation field, choose SM3.
Set Length to 64.
Give your Output field a name and click Save. You'll get the SM3 hashes of your input strings.

For example:

Hello World! -> 0ac0a9fef0d212aa

You can try out operations with specific values using the Input field above the operation. You can enter the value in the example above and check the result in the Output field.

Networking

Defang IP Address

Description

This operation takes an IPv4 or IPv6 address and 'defangs' it, meaning the IP becomes invalid, removing the risk of accidentally using it as an IP address. The operation replaces certain characters with alternatives, making the IP non-functional.

Data types

These are the input/output expected data types for this operation:

Input data

- IP addresses you want to defang.

Output data

- Defanged IP addresses.

Example

Suppose you want to defang a series of events that represent IP addresses:

In your Pipeline, open the required configuration and select the input Field.
In the Operation field, choose Defang IP Address.
Give your Output field a name and click Save. The IP addresses in your input field will be defanged. For example:

You can try out operations with specific values using the Input field above the operation. You can enter the value in the example above and check the result in the Output field.

Defang URL

Description

This operation makes URLs safe to share by preventing accidental clicks or access. This is especially useful in cybersecurity contexts, where you might need to share potentially malicious URLs without making them active links.

Data types

These are the input/output expected data types for this operation:

Input data

- URLs you want to defang.

Output data

- Defanged URLs.

Parameters

These are the parameters you need to configure to use this operation (mandatory parameters are marked with a *):

Escape Dots*

Set this parameter to true if you want to replace . in the domain with [.]. This breaks the URL’s domain and subdomain structure, making the URL inactive. For example, example.com becomes example[.]com.

Escape HTTP*

Set this parameter to true if you want to modify http or https to hxxp or hxxps, respectively. This makes the protocol itself inactive, adding an extra layer of safety.

Escape ://*

Set this parameter to true if you want to replace the :// separator with [://], making it clear where the protocol ends while breaking its functionality.

Process Type*

Choose one of the following options:

Valid domains and full URLs - Processes both complete URLs (like https://example.com) and standalone domain names (like example.com) for defanging.
Only full URLs - Processes only fully qualified URLs, ignoring standalone domain names.
Everything - Applies defanging to all potential URLs, domain names, or anything resembling a URL in the text.

Example

Suppose you want to defang a series of events that represent URLs:

In your Pipeline, open the required Action configuration and select the input Field.
In the Operation field, choose Defang URL.
Set Escape Dots to true.
Set Escape HTTP to true.
Set Escape ://* to false.
Set Process Type to Everything.
Give your Output field a name and click Save. The URLs in your input field will be defanged. For example:

https://example.com -> hxxps://example[.]com

You can try out operations with specific values using the Input field above the operation. You can enter the value in the example above and check the result in the Output field.

Extract IP Address

Description

This operation extracts all the IPv4 and IPv6 addresses from a block of text or data.

Data types

These are the input/output expected data types for this operation:

Input data

- Strings with a block of IP addresses you want to extract.

Output data

- List of IP addresses.

Example

Suppose you want to extract a list of IP addresses from your input strings. To do it:

In your Pipeline, open the required configuration and select the input Field.
In the Operation field, choose Extract IP Address.
Give your Output field a name and click Save.

For example, in this input text:

this will be the output list of IP addresses detected:

You can try out operations with specific values using the Input field above the operation. You can enter the value in the example above and check the result in the Output field.

Fang URLs

Description

This operation takes a 'defanged' URL and 'fangs' it, meaning, it removes the alterations that render it useless so that it can be used again.

Data types

These are the input/output expected data types for this operation:

Input data

- URLs you want to fang.

Output data

- Valid URLs.

Parameters

These are the parameters you need to configure to use this operation (mandatory parameters are marked with a *):

Escape Dots*

Set this parameter to true if you want to restore . in the URL domains. For example, example[.]com becomes example.com.

Escape HTTP*

Set this parameter to true if you want to restore hxxp or hxxps and make them http or https, respectively.

Escape ://*

Set this parameter to true if you want to restore the :// separator in your URLs.

Process Type*

Choose one of the following options:

Valid domains and full URLs - Processes both complete URLs (like https://example.com) and standalone domain names (like example.com).
Only full URLs - Processes only fully qualified URLs, ignoring standalone domain names.
Everything - Processes all potential URLs, domain names, or anything resembling a URL in the text.

Example

Suppose you want to fang a series of events that represent URLs:

In your Pipeline, open the required Action configuration and select the input Field.
In the Operation field, choose Fang URL.
Set Escape Dots to true.
Set Escape HTTP to true.
Set Escape ://* to false.
Set Process Type to Everything.
Give your Output field a name and click Save. The URLs in your input field will be made valid. For example:

hxxps://example[.]com -> hxxps://example.com

You can try out operations with specific values using the Input field above the operation. You can enter the value in the example above and check the result in the Output field.

URL Decode

Description

This operation converts a URL-encoded string back to its original format. URL encoding is used to encode special characters in URLs to ensure safe and proper transmission over the internet. When decoding, these encoded characters are translated back to their human-readable form.

Data types

These are the input/output expected data types for this operation:

Input data

- URL-encoded strings to be decoded.

Output data

- Decoded versions of your URLs.

Example

Suppose you want to decode a series of URL-encoded strings in your input data. To do it:

In your Pipeline, open the required Action configuration and select the input Field.
In the Operation field, choose URL decode.
Give your Output field a name and click Save. Your URL-encoded strings will be converted.

For example the following URL-encoded string:

https%3A%2F%2Fexample.com%2Fsearch%3Fq%3DHello+World%21

will be decoded like this:

https://example.com/search?q=Hello World!

You can try out operations with specific values using the Input field above the operation. You can enter the value in the example above and check the result in the Output field.

URL Encode

Description

This operation converts a URL into an encoded string. URL encoding is used to encode special characters in URLs to ensure safe and proper transmission over the internet.

Data types

These are the input/output expected data types for this operation:

Input data

- URLs to be encoded

Output data

- Resulting encoded strings of your URLs.

Example

Suppose you want to encode a series of URLs in your input data. To do it:

In your Pipeline, open the required Action configuration and select the input Field.
In the Operation field, choose URL encode.
Give your Output field a name and click Save. Your URLs will be converted.

For example the following URL-encoded string:

https://example.com/search?q=Hello World!

will be encoded like this:

https%3A%2F%2Fexample.com%2Fsearch%3Fq%3DHello+World%21

You can try out operations with specific values using the Input field above the operation. You can enter the value in the example above and check the result in the Output field.

Other

Parse Int

Description

This operation parses a string and returns an integer of the specified base (or radix).

In a positional numeral system, the base is the number of unique digits, including the digit zero, used to represent numbers. For example, for the decimal system, the radix is ten, because it uses the ten digits from 0 through 9.

In any standard positional numeral system, a number is conventionally written as (x)y with x as the string of digits and y as its base. However, for base ten the subscript is usually assumed (and omitted, together with the pair of parentheses), as it is the most common way to express value. For example, (100)10 is equivalent to 100 (the decimal system is implied in the latter) and represents the number one hundred, while (100)2 (in the binary system with base 2) represents the number four.

Commonly used numeral systems include:

2 - Binary numeral system
8 - Octal system
10 - Decimal system
12 - Duodecimal (dozenal) system
16 - Hexadecimal system
20 - Vigesimal system
36 - Base36
60 - Sexagesimal system

Data types

These are the input/output expected data types for this operation:

Input data

Output data

Parameters

These are the parameters you need to configure to use this operation (mandatory parameters are marked with a *):

Base*

An integer between 2 and 36 that represents the string's base.

If it's nonzero and outside the range 2-36, the operation will always fail.

If the base argument is 0, the true base is implied by the string's prefix with leading whitespace and possible +/- signs removed:

2 for 0b.
8 for 0 or 0o.
16 for 0x.
and 10 otherwise.

For example, if your string is 0b100 and you enter 0 as Base, the operation will assume that the true base is 2.

Example

Suppose you want to parse a series of strings and convert them to integers according to a specific base:

In your Pipeline, open the required Action configuration and select the input Field.
In the Operation field, choose Parse int.
Set Base to 2.
Give your Output field a name and click Save. The strings in your input field will be parsed according to the specified base. In this example:

100(2) -> 4

You can try out operations with specific values using the Input field above the operation. You can enter the value in the example above and check the result in the Output field.

Text sample adding

Pad Lines

Description

This operation allows you to add padding characters to the beginning or end of each line of text. This operation is useful for formatting text, aligning data, or preparing output for specific requirements such as indentation or prefixing/suffixing lines.

Data types

These are the input/output expected data types for this operation:

Input data

- Input text to be padded. The operation processes multiline text where each line is treated as a separate unit.

Output data

- Each line in the input will be padded based on the selected options.

Parameters

These are the parameters you need to configure to use this operation (mandatory parameters are marked with a *):

Pad position*

Determines where the padding is applied to each line of text. This parameter allows for flexible control over how padding is added, enabling you to customize the output to meet specific formatting requirements. Enter one of the following:

Start - Applies the padding at the right of the strings.
End - Applies the padding at the left of the strings.

Pad length*

Enter the total number of characters you want your padding to have in each line. Padding will be filled with the characters set in the Characters parameter until reaching the required length.

Characters

This allows you to specify which character(s) will be used for padding. This is the string that will be added to the beginning or end of each line to achieve the desired padding effect, as defined by the Pad position and Pad length parameters.

Example

Suppose you want to add padding to a series of events:

In your Pipeline, open the required Action configuration and select the input Field.
In the Operation field, choose Pad lines.
Set Pad position to Start.
Set Pad length to 7.
Set Characters to >>>
Give your Output field a name and click Save. The strings in your input field will be modified with the specified padding.

For example, the following lines:

Apple
Banana
Cherry

will be transformed into:

>>> >>>Apple
>>> >>>Banana
>>> >>>Cherry

You can try out operations with specific values using the Input field above the operation. You can enter the value in the example above and check the result in the Output field.

Utils

Byte to Human Readable

Description

This operation converts a size in bytes into a more human-friendly format, such as kilobytes (KB), megabytes (MB), gigabytes (GB), and so on. This operation is especially useful for interpreting file sizes or data storage values.

Data types

These are the input/output expected data types for this operation:

Input data

- Sizes in bytes to be transformed. They must be strings that represent integer numbers.

Output data

- Resulting human-readable strings.

Example

Suppose you want to convert a series of events that represent sizes in bytes into human-readable strings:

In your Pipeline, open the required Action configuration and select the input Field.
In the Operation field, choose Byte to Human Readable.
Give your Output field a name and click Save. The byte sizes in your input field will be transformed into human-readable strings. For example:

134367 -> 131.22 KiB

You can try out operations with specific values using the Input field above the operation. You can enter the value in the example above and check the result in the Output field.

Count Occurrences

Description

This operation counts the number of times a provided string (character, word, or phrase) appears in the given input data.

Data types

These are the input/output expected data types for this operation:

Input data

- Data you want to analyze.

Output data

- Count of the specified character, word, or pattern you searched for.

Parameters

These are the parameters you need to configure to use this operation (mandatory parameters are marked with a *):

Search*

Enter the specific character, word, or pattern you want to count.

Search Type*

Select the type of search you want to perform. The available options are:

simple - Choose this option if you want to perform a simple string matching. Note that this search type is not case-sensitive (A is different from a).
regex - Choose this option if you want to use regular expressions.
extended - Choose this option for extended regular expressions. An extended regular expression specifies a set of strings to be matched. The expression contains both text characters and operator characters.

Examples

Simple search example

Suppose you want to check the number of occurrences of the term test in a series of events:

In the Operation field, choose Count occurrences.
Set Search to test.
Set Search Type to simple.
Give your Output field a name and click Save. The count will be displayed in the output field.

In this example, given the following string:

The result count will be 1.

RegEx search example

Suppose you want to count words that start with the letter "c" (either small or capital) in your input data:

In the Operation field, choose Count occurrences.
Set Search to \b[Cc]\w*.
Set Search Type to regex.
Give your Output field a name and click Save. The count will be displayed in the output field.

In this example, given the following string:

The result count will be 3.

RegEx explanation:

\b matches a word boundary, ensuring the match starts at the beginning of a word.
C matches the letter "c."
\w* matches any number of alphanumeric characters after "C," effectively capturing entire words.

Extended RegEx search example

Suppose you want to get the occurrences of the word "error" but not if it’s followed by "404". To do it:

In the Operation field, choose Count occurrences.
Set Search to error(?!\s404).
Set Search Type to extended.
Give your Output field a name and click Save. The count will be displayed in the output field.

In this example, given the following strings:

The result count will be 2.

RegEx explanation:

error matches the word "error."
(?!\s404) is a negative lookahead that ensures "error" is not followed by " 404".

You can try out operations with specific values using the Input field above the operation. You can enter the value in the example above and check the result in the Output field.

CRC8 Checksum

Description

This operation calculates an 8-bit Cyclic Redundancy Check (CRC) value for a given input. A cyclic redundancy check (CRC) is an error-detecting code commonly used in digital networks and storage devices to detect accidental changes to raw data.

The algorithm uses a fixed 8-bit polynomial to calculate a short "fingerprint" of the input data, resulting in an 8-bit (one-byte) checksum. This checksum can detect certain types of errors, like single-bit errors or burst errors up to 8 bits, by recalculating the checksum and comparing it with the original.

Data types

These are the input/output expected data types for this operation:

Input data

- Data you want to compute the CRC-8 checksum for.

Output data

- CRC-8 values of your input data.

Example

Suppose you want to calculate the CRC-8 of a specific set of data:

In your Pipeline, open the required configuration and select the input Field.
In the Operation field, choose CRC8 Checksum.
Give your Output field a name and click Save. The operation will calculate the CRC8 codes for the strings in your input field. For example:

You can try out operations with specific values using the Input field above the operation. You can enter the value in the example above and check the result in the Output field.

CRC16 Checksum

Description

This operation calculates a 16-bit Cyclic Redundancy Check (CRC) value for a given input. A cyclic redundancy check (CRC) is an error-detecting code commonly used in digital networks and storage devices to detect accidental changes to raw data.

The algorithm uses a fixed 16-bit polynomial to calculate a short "fingerprint" of the input data, resulting in a 16-bit (one-byte) checksum. This checksum can detect certain types of errors, like single-bit errors or burst errors up to 16 bits, by recalculating the checksum and comparing it with the original.

Data types

These are the input/output expected data types for this operation:

Input data

- Data you want to compute the CRC-16 checksum for.

Output data

- CRC-16 values of your input data.

Example

Suppose you want to calculate the CRC-16 of a specific set of data:

In your Pipeline, open the required configuration and select the input Field.
In the Operation field, choose CRC16 Checksum.
Give your Output field a name and click Save. The operation will calculate the CRC16 codes for the strings in your input field. For example:

You can try out operations with specific values using the Input field above the operation. You can enter the value in the example above and check the result in the Output field.

CRC24 Checksum

Description

This operation calculates a 24-bit Cyclic Redundancy Check (CRC) value for a given input. A cyclic redundancy check (CRC) is an error-detecting code commonly used in digital networks and storage devices to detect accidental changes to raw data.

The algorithm uses a fixed 24-bit polynomial to calculate a short "fingerprint" of the input data, resulting in a 24-bit (one-byte) checksum. This checksum can detect certain types of errors, like single-bit errors or burst errors up to 24 bits, by recalculating the checksum and comparing it with the original.

Data types

These are the input/output expected data types for this operation:

Input data

- Data you want to compute the CRC-24 checksum for.

Output data

- CRC-24 values of your input data.

Example

Suppose you want to calculate the CRC-24 of a specific set of data:

In your Pipeline, open the required Action configuration and select the input Field.
In the Operation field, choose CRC24 Checksum.
Give your Output field a name and click Save. The operation will calculate the CRC24 codes for the strings in your input field. For example:

hello 1234 -> 3B6473

You can try out operations with specific values using the Input field above the operation. You can enter the value in the example above and check the result in the Output field.

CRC32 Checksum

Description

This operation calculates a 32-bit Cyclic Redundancy Check (CRC) value for a given input. A cyclic redundancy check (CRC) is an error-detecting code commonly used in digital networks and storage devices to detect accidental changes to raw data.

The algorithm uses a fixed 32-bit polynomial to calculate a short "fingerprint" of the input data, resulting in a 32-bit (one-byte) checksum. This checksum can detect certain types of errors, like single-bit errors or burst errors up to 32 bits, by recalculating the checksum and comparing it with the original.

Data types

These are the input/output expected data types for this operation:

Input data

- Data you want to compute the CRC-32 checksum for.

Output data

- CRC-32 values of your input data.

Example

Suppose you want to calculate the CRC-32 of a specific set of data:

In your Pipeline, open the required configuration and select the input Field.
In the Operation field, choose CRC32 Checksum.
Give your Output field a name and click Save. The operation will calculate the CRC32 codes for the strings in your input field. For example:

You can try out operations with specific values using the Input field above the operation. You can enter the value in the example above and check the result in the Output field.

Credit Card Obfuscator

Description

This operation obfuscates all digits of a credit card number except for the last 4 digits.

Data types

These are the input/output expected data types for this operation:

Input data

- The input strings to be obfuscated.

Output data

- Resulting credit card numbers with the digits obfuscated.

Example

Suppose you want to obfuscate a series of credit card numbers in your input strings:

In your Pipeline, open the required configuration and select the input Field.
In the Operation field, choose Credit card obfuscator.
Give your Output field a name and click Save. The credit card numbers in your input field will be obfuscated. For example:

You can try out operations with specific values using the Input field above the operation. You can enter the value in the example above and check the result in the Output field.

Filter

Description

This operation allows you to filter lines of text based on specific conditions or patterns. This operation is useful when you want to keep only lines that match a certain pattern or exclude lines that don't meet specific criteria.

Data types

These are the input/output expected data types for this operation:

Input data

- The input strings to be split and filtered.

Output data

- The filtered results after applying the regular expression and delimiter.

Parameters

These are the parameters you need to configure to use this operation (mandatory parameters are marked with a *):

Delimiter

Choose the delimiter that separates each segment in your input data:

Line feed - Select this to will each line of text as a separate value.
Space - Your segments are separated by spaces.
Comma - Your segments are separated by commas (,)
Semi-colon - Your segments are separated by semi-colons (;)
Colon - Your segments are separated by colons (:)
CRLF - Carriage return line feed (CRLF) is a control character that originally referred to moving the carriage on typewriters back to the starting position. In computing, it’s used in classic Mac OS and some Windows-based systems to mark the end of a line. If your input uses \r as the line-ending character, you can set the delimiter to \r to correctly separate values. For example: 100\r200\r300
Nothing (separate chars)

Regex

Define the pattern for filtering using a regular expression, which enables more complex matching conditions.

Invert

Set this parameter to true if you want to reverse the filter logic, so it keeps lines that do not match the specified pattern.

Example

Suppose you want to filter a series of strings to extract only segments that start with error:

In your Pipeline, open the required Action configuration and select the input Field.
In the Operation field, choose Filter.
Set Delimiter to Line feed
Set Regex to ^Error
Set Invert to false.
Give your Output field a name and click Save. The strings in your input field will be filtered with the specified conditions.

For example, this text:

Error: File not found
Warning: Low memory
Info: Operation completed
Error: Disk full

will be filtered as:

Error: File not found
Error: Disk full

You can try out operations with specific values using the Input field above the operation. You can enter the value in the example above and check the result in the Output field.

Find and Replace

Description

This operation allows you to search for specific patterns within your input data and replace them with new text. This operation is versatile, offering options for simple text replacements, complex pattern-based replacements using regular expressions (regex), and even case-sensitive or case-insensitive matching.

Data types

These are the input/output expected data types for this operation:

Input data

- Text or data where you want to perform find-and-replace operations.

Output data

- Output strings after the find-and-replace operations.

Parameters

These are the parameters you need to configure to use this operation (mandatory parameters are marked with a *):

Substring to find

Enter the text or pattern you want to find in the input.

Replacement

Enter the text with which you want to replace each match.

Examples

Suppose you want to replace all the occurrences of the word "error" with "issue". To do it:

In your Pipeline, open the required Action configuration and select the input Field.
In the Operation field, choose Find and replace.
Set Substring to find to error.
Set Replacement to issue.
Give your Output field a name and click Save. The count will be displayed in the output field.

You can try out operations with specific values using the Input field above the operation. You can enter the value in the example above and check the result in the Output field.

In this example, given the following string:

The server encountered an error while processing your request.

you'll get this output:

The server encountered an issue while processing your request.

Regex

Description

This operation allows you to extract or manipulate parts of your input strings that match a specific regular expression pattern.

Data types

These are the input/output expected data types for this operation:

Input data

- The strings from which you want to pull out specific parts.

Output data

- The resulting strings that match your regular expression.

Parameters

These are the parameters you need to configure to use this operation (mandatory parameters are marked with a *):

Regex*

Enter the RegEx pattern you want to use for matching.

Example

Suppose you want to remove spaces, line feeds and full stops from your input strings:

In your Pipeline, open the required Action configuration and select the input Field.
In the Operation field, choose Regex.
Set Regex to [a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+.[a-zA-Z]{2,}
Give your Output field a name and click Save.

With the parameters set above, the following text:

Hello, you can contact us at support@example.com or sales@company.org for assistance.

will be transformed like this:

support@example.com
sales@company.org

You can try out operations with specific values using the Input field above the operation. You can enter the value in the example above and check the result in the Output field.

Remove Whitespace

Description

This operation allows you to clean up text by eliminating unnecessary whitespace characters. This includes spaces, tabs, newlines, and other types of whitespace that might be present in your input data.

Data types

These are the input/output expected data types for this operation:

Input data

- The strings from which the whitespace characters will be removed.

Output data

- The resulting strings after removing the specified characters.

Parameters

These are the parameters you need to configure to use this operation (mandatory parameters are marked with a *):

Spaces

Set this parameter to true if you want to remove spaces from your input strings.

Carriage returns

Set this parameter to true if you want to remove carriage returns (\r) from your input strings.

Line feeds

Set this parameter to true if you want to remove line feeds (\n) from your input strings.

Tabs

Set this parameter to true if you want to remove tab characters (\t) from your input strings.

Form feeds

Set this parameter to true if you want to remove form feeds (\f) from your input strings.

Full stops

Set this parameter to true if you want to remove full stops (.) from your input strings.

Example

Suppose you want to remove spaces, line feeds and full stops from your input strings:

In the Operation field, choose Remove whitespace.
Set Spaces to true.
Set Carriage returns to false.
Set Line feeds to true.
Set Tabs to false.
Set Form feeds to false.
Set Full stops to true.
Give your Output field a name and click Save.

With the parameters set above, the following text:

will be transformed like this:

You can try out operations with specific values using the Input field above the operation. You can enter the value in the example above and check the result in the Output field.

Reverse String

Description

This operation allows you to reverse the order of characters in a given string. This operation is handy for text manipulation, encoding challenges, and debugging scenarios where reversing the text is required.

Data types

These are the input/output expected data types for this operation:

Input data

- The strings of text that you want to reverse.

Output data

- Reversed strings.

Parameters

These are the parameters you need to configure to use this operation (mandatory parameters are marked with a *):

Reverse mode

Choose the method you want to use to reverse your input strings. Enter one of the following options:

Character - Reverses the order of characters in the entire input.

For example, this string:

Hello World!

would be transformed like this:

!dlroW olleH

Line - Reverses the order of lines in the input.

For example, these strings:

Hello World!

This is an example

would be transformed like this:

This is an example

Hello World!

Byte - Reverses the order of bytes in the entire input, assuming ASCII encoding where each character is one byte. This is useful when dealing with binary data, hexadecimal values, or encoded formats where the order of the bytes needs to be reversed for processing or analysis.

For example, this string:

48656c6c6f20576f726c64

would be transformed like this:

646c726f57206f6c6c6548

Example

Suppose you want to reverse a series of strings in your input data:

In your Pipeline, open the required Action configuration and select the input Field.
In the Operation field, choose Reverse string.
Set Reverse mode to Character.
Give your Output field a name and click Save.

With the parameters set above, the following text:

Hello World!

will be transformed like this:

!dlroW olleH

You can try out operations with specific values using the Input field above the operation. You can enter the value in the example above and check the result in the Output field.

Shuffle

Description

This operation rearranges the elements of an input string, list, or dataset into a random order. It’s a useful operation for tasks like randomization, testing, or introducing entropy into datasets.

Data types

These are the input/output expected data types for this operation:

Input data

- Strings whose characters will be shuffled.

Output data

- Resulting strings after shuffling the characters.

Parameters

These are the parameters you need to configure to use this operation (mandatory parameters are marked with a *):

Delimiter

Specifies a delimiter to split the input string before shuffling. Each segment of the string, separated by the delimiter, will be shuffled independently. If no delimiter is provided, the entire string is shuffled as a single unit.

Supported delimiters are:

Line feed - Select this to will each line of text as a separate value.
Space - Your segments are separated by spaces.
Comma - Your segments are separated by commas (,)
Semi-colon - Your segments are separated by semi-colons (;)
Colon - Your segments are separated by colons (:)
CRLF - Carriage return line feed (CRLF) is a control character that originally referred to moving the carriage on typewriters back to the starting position. In computing, it’s used in classic Mac OS and some Windows-based systems to mark the end of a line. If your input uses \r as the line-ending character, you can set the delimiter to \r to correctly separate values. For example: 100\r200\r300
Nothing (separate chars)

Example

Suppose you want to shuffle the characters of a series of strings in your input data:

In your Pipeline, open the required Action configuration and select the input Field.
In the Operation field, choose Shuffle.
Set Delimiter to Nothing (separate chars).
Give your Output field a name and click Save. The characters in your input strings will be shuffled.

For example:

Hello World! -> rH Wl!odolle

You can try out operations with specific values using the Input field above the operation. You can enter the value in the example above and check the result in the Output field.

Swap Case

Description

This operation alters the case of each letter in a given input, swapping uppercase letters to lowercase and lowercase letters to uppercase. Non-alphabetic characters remain unchanged.

Data types

These are the input/output expected data types for this operation:

Input data

- String of text containing letters (upper or lower case), numbers, symbols, or other characters.

Output data

- The resulting string with swapped case.

Example

Suppose you want to swap the case of the characters your input data:

In your Pipeline, open the required Action configuration and select the input Field.
In the Operation field, choose Swap case.
Give your Output field a name and click Save.

For example:

Hello World! -> hELLO wORLD!

You can try out operations with specific values using the Input field above the operation. You can enter the value in the example above and check the result in the Output field.

To Lower Case

Description

This operation converts all characters in a string or text to their lowercase equivalents. This transformation is often used to standardize text for tasks like case-insensitive comparisons, sorting, or data normalization.

Data types

These are the input/output expected data types for this operation:

Input data

- Strings to be converted.

Output data

- Strings where all uppercase letters (A-Z) have been converted to their lowercase counterparts (a-z). Characters that are already lowercase or are not alphabetic (e.g., numbers, symbols, whitespace) remain unchanged.

Example

Suppose you want to convert all the characters of a series of strings in your input data to lowercase:

In your Pipeline, open the required configuration and select the input Field.
In the Operation field, choose To lower case.
Give your Output field a name and click Save. The characters in your input strings will be converted to lowercase.

For example:

You can try out operations with specific values using the Input field above the operation. You can enter the value in the example above and check the result in the Output field.

To Upper Case

Description

This operation converts all characters in a string or text to their uppercase equivalents.

Data types

These are the input/output expected data types for this operation:

Input data

- Strings to be converted.

Output data

- Strings where all lowercase letters (a-z) have been converted to their uppercase counterparts (A-Z).

Example

Suppose you want to convert all the characters of a series of strings in your input data to uppercase:

In your Pipeline, open the required Action configuration and select the input Field.
In the Operation field, choose To upper case.
Give your Output field a name and click Save. The characters in your input strings will be converted to uppercase.

For example:

Hello World! -> HELLO WORLD!

You can try out operations with specific values using the Input field above the operation. You can enter the value in the example above and check the result in the Output field.

Sort

Description

This operation arranges the elements of an input (e.g., words, numbers, or lines) in a specific order. It is useful for organizing data, analyzing patterns, or preparing datasets for further processing.

Data types

These are the input/output expected data types for this operation:

Input data

- Input strings to be sorted.

Output data

- Sorted data.

Parameters

These are the parameters you need to configure to use this operation (mandatory parameters are marked with a *):

Delimiter*

Choose the delimiter that separates each segment in your input data. Enter one of the following:

Line feed - Select this to will each line of text as a separate value.
Space - Your segments are separated by spaces.
Comma - Your segments are separated by commas (,)
Semi-colon - Your segments are separated by semi-colons (;)
Colon - Your segments are separated by colons (:)
CRLF - Carriage return line feed (CRLF) is a control character that originally referred to moving the carriage on typewriters back to the starting position. In computing, it’s used in classic Mac OS and some Windows-based systems to mark the end of a line. If your input uses \r as the line-ending character, you can set the delimiter to \r to correctly separate values. For example: 100\r200\r300
Nothing (separate chars)

Order*

Choose the type of sorting to be applied. Enter one of the following:

Alphabetical (case sensitive) - Rearranges the elements in alphabetical order, considering case.
Alphabetical (case insensitive) - Rearranges the elements in alphabetical order, ignoring case.
IP address - Sorts a list of IP addresses in numerical order, rather than treating them as strings.
Numeric - Sorts values as numbers rather than strings. This ensures proper numerical order, where 2 comes before 10, unlike a lexicographic sort which might order them as 10, 2.
Numeric (hexadecimal) - Sorts hexadecimal numbers as their numeric equivalents, not as strings. For example, 0x1A (26 in decimal) will come before 0xF (15 in decimal), regardless of their string order.
Length - The elements are sorted based on their length, from shortest to longest.

Reverse

Set this parameter to true if you want to reverse the order of the sorted elements.

Example

Suppose you want to sort the terms of a series of strings in your input data:

In your Pipeline, open the required Action configuration and select the input Field.
In the Operation field, choose Sort.
Set Delimiter to Comma.
Set Order to Alphabetical (case sensitive).
Set Reverse to false.
Give your Output field a name and click Save. The terms in your input field will be sorted following the specified conditions.

For example, this text:

banana,apple,orange,grape

will be sorted as:

apple,banana,grape,orange

You can try out operations with specific values using the Input field above the operation. You can enter the value in the example above and check the result in the Output field.