DPL Numeric Data

• Latest Dynatrace
• Reference
• Updated on Aug 06, 2026

Overview

This page documents the DPL matchers for numeric data. Matchers in the same family accept the same input but differ in output type or supported range—the tables below compare the related matchers side by side.

Integer matchers

See how to use in DQL

data record(input = "-10"),
     record(input = "2.5"),
     record(input = "3,6"),
     record(input = "0xa01F"),
     record(input = "2147483647"),
     record(input = "2147483648"),
     record(input = "9223372036854775807"),
     record(input = "9223372036854775808"),
     record(input = " ")
| parse input, "INT:int"
| parse input, "LONG:long"

Hexadecimal matchers

See how to use in DQL

data record(input = "0xa01F"),
     record(input = "x3"),
     record(input = "-xFE"),
     record(input = "10fE"),
     record(input = "0xFFFFFFFF"),
     record(input = "0x7FFFFFFFFFFFFFFF"),
     record(input = "0x8000000000000000"),
     record(input = "word"),
     record(input = " ")
| parse input, "HEXINT:hexint"
| parse input, "HEXLONG:hexlong"

BOOLEAN

Matches case-insensitive strings true and false.

Use the following pattern to parse boolean values:

BOOLEAN:result

For example, parsing boolean strings in different cases:

See how to use in DQL

data record(input = "true"),
     record(input = "FALSE"),
     record(input = "TrUe"),
     record(input = "1"),
     record(input = "yes"),
     record(input = " ")
| parse input, "BOOLEAN:result"

Returns

The data type of the extracted value is boolean.

Practical examples

Example 1: Parse boolean feature flag values

Given the following input:

debug_enabled=true

Use the following pattern to extract the boolean value:

'debug_enabled=' BOOLEAN:result

See how to use in DQL

data record(input = "debug_enabled=true")
| parse input, "'debug_enabled=' BOOLEAN:result"

Example 2: Match a field that contains a valid boolean

Given the following input:

debug_enabled=maybe

Use the following pattern to check whether the field contains a valid boolean:

'debug_enabled=' BOOLEAN

We get the following output:

See how to use in DQL

data record(input = "debug_enabled=maybe")
| fieldsAdd result = matchesPattern(input, "'debug_enabled=' BOOLEAN")

FLOAT

Matches floating point numbers in the form of [+|-]?[0-9]+[.0-9]* (dot "." separated) or [+|-]?[0-9]+[E|e0-9]* (scientific notation).

Use the following pattern to parse float values:

FLOAT:result

For example, parsing float values in different formats:

See how to use in DQL

data record(input = "3e0"),
     record(input = "1"),
     record(input = "0.1"),
     record(input = "9,3"),
     record(input = " ")
| parse input, "FLOAT:result"

Configuration

Specify configuration parameters in parentheses after the matcher name: FLOAT(min=value, max=value):result.

Returns

The data type of the extracted value is double.

Basic example

Example: Match float values against a predefined range

The following pattern checks if a float value is between 1 and 3:

FLOAT(min=1, max=3)

See how to use in DQL

data record(input = "2.5"),
     record(input = "3.0"),
     record(input = "0.5"),
     record(input = "3.5")
| fieldsAdd result = matchesPattern(input, "FLOAT(min=1, max=3)")

Practical examples

Example 1: Parse the Mozilla and Firefox versions

Given the following input:

Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:123.0) Gecko/20100101 Firefox/123.0

Use the following pattern to extract the Mozilla and Firefox versions:

'Mozilla/' FLOAT:mozilla DATA 'Firefox/' FLOAT:firefox

See how to use in DQL

data record(input = "Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:123.0) Gecko/20100101 Firefox/123.0")
| parse input, """'Mozilla/' FLOAT:mozilla DATA 'Firefox/' FLOAT:firefox"""

Example 2: Match Firefox version 148 or higher

Given the following input:

Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:123.0) Gecko/20100101 Firefox/123.0

Use the following pattern to check whether the Firefox version is 148 or higher:

LD 'Firefox/' FLOAT(min=148)

We get the following output:

See how to use in DQL

data record(input = "Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:123.0) Gecko/20100101 Firefox/123.0")
| fieldsAdd result = matchesPattern(input, """LD 'Firefox/' FLOAT(min=148)""")

CFLOAT

Same as FLOAT, but uses comma , as decimal separator: [+|-]?[0-9]+[,0-9]* or [+|-]?[0-9]+[E|e0-9]*.

Use the following pattern to parse comma-decimal float values:

CFLOAT:result

For example, parsing comma-decimal float values:

See how to use in DQL

data record(input = "1,5"),
     record(input = "1.5"),
     record(input = "3e0"),
     record(input = "1"),
     record(input = " ")
| parse input, "CFLOAT:result"

Configuration

Specify configuration parameters in parentheses after the matcher name: CFLOAT(min=value, max=value):result.

Returns

The data type of the extracted value is double.

Basic example

Example: Match comma-decimal float values against a range

The following pattern checks if a comma-decimal value is between 1 and 5:

CFLOAT(min=1, max=5)

See how to use in DQL

data record(input = "2,5"),
     record(input = "5,0"),
     record(input = "0,5"),
     record(input = "6,0")
| fieldsAdd result = matchesPattern(input, "CFLOAT(min=1, max=5)")

DOUBLE

Matches floating point numbers in the form of [+|-]?[0-9]+[.0-9]* (dot "." separated) or [+|-]?[0-9]+[E|e0-9]* (scientific notation).

Use the following pattern to parse double values:

DOUBLE:result

For example, parsing double values in different formats:

See how to use in DQL

data record(input = "3e0"),
     record(input = "1"),
     record(input = "0.15"),
     record(input = "0,15"),
     record(input = " ")
| parse input, "DOUBLE:result"

Configuration

Specify configuration parameters in parentheses after the matcher name: DOUBLE(min=value, max=value):result.

Returns

The data type of the extracted value is double.

Basic example

Example: Match double values against a predefined range

The following pattern checks if a double value is between 0 and 1:

DOUBLE(min=0, max=1)

See how to use in DQL

data record(input = "0.15"),
     record(input = "1.0"),
     record(input = "1.5"),
     record(input = " ")
| fieldsAdd result = matchesPattern(input, "DOUBLE(min=0, max=1)")

Practical example

Example: Parse CPU and memory metric values

Given the following input:

metrics cpu.load=0.85 mem.used=2.5

Use the following pattern to extract the CPU load and memory usage:

LD 'cpu.load=' DOUBLE:cpu_load SPACE 'mem.used=' DOUBLE:mem_used

See how to use in DQL

data record(input = "metrics cpu.load=0.85 mem.used=2.5")
| parse input, "LD 'cpu.load=' DOUBLE:cpu_load SPACE 'mem.used=' DOUBLE:mem_used"

CDOUBLE

Same as DOUBLE, but uses comma , as decimal separator: [+|-]?[0-9]+[,0-9]* or [+|-]?[0-9]+[E|e0-9]*.

Use the following pattern to parse comma-decimal double values:

CDOUBLE:result

For example, parsing comma-decimal double values:

See how to use in DQL

data record(input = "1,5"),
     record(input = "1.5"),
     record(input = "3e0"),
     record(input = "1"),
     record(input = " ")
| parse input, "CDOUBLE:result"

Configuration

Specify configuration parameters in parentheses after the matcher name: CDOUBLE(min=value, max=value):result.

Returns

The data type of the extracted value is double.

Basic example

Example: Match comma-decimal double values against a range

The following pattern checks if a comma-decimal value is between 0 and 2:

CDOUBLE(min=0, max=2)

See how to use in DQL

data record(input = "1,5"),
     record(input = "2,0"),
     record(input = "2,5")
| fieldsAdd result = matchesPattern(input, "CDOUBLE(min=0, max=2)")

INT, INTEGER

Matches integral numbers in the form of [+|-]?[0-9]+ with values in the range -2147483648 to 2147483647. INTEGER is an alias for INT.

Use the following pattern to parse integer values:

INT:result

For example, parsing integer values including negative numbers:

See how to use in DQL

data record(input = "-10"),
     record(input = "2.5"),
     record(input = "3,6"),
     record(input = "0xa01F"),
     record(input = "2147483647"),
     record(input = "2147483648"),
     record(input = "9223372036854775807"),
     record(input = "9223372036854775808"),
     record(input = " ")
| parse input, "INT:result"

Configuration

Specify configuration parameters in parentheses after the matcher name: INT(min=value, max=value):result.

Returns

The data type of the extracted value is long.

Basic example

Example: Match integer values against a predefined range

The following pattern checks if an integer value is a valid HTTP 2xx status code:

INT(min=200, max=299)

See how to use in DQL

data record(input = "200"),
     record(input = "201"),
     record(input = "404"),
     record(input = "500")
| fieldsAdd result = matchesPattern(input, "INT(min=200, max=299)")

Practical example

Example: Parse an HTTP status code value

Given the following input:

GET /api/users HTTP/1.1 200 1234

Use the following pattern to extract the HTTP status code and response size:

LD 'HTTP/1.1 ' INT:status SPACE INT:bytes

See how to use in DQL

data record(input = "GET /api/users HTTP/1.1 200 1234")
| parse input, "LD 'HTTP/1.1 ' INT:status SPACE INT:bytes"

HEXINT

Matches integral numbers in hexadecimal notation [+|-]?0?x?[0-9a-fA-F]+ with values in the range -2147483648 to 2147483647.

Use the following pattern to parse hexadecimal integer values:

HEXINT:result

For example, parsing hexadecimal values in different notations:

See how to use in DQL

data record(input = "0xa01F"),
     record(input = "x3"),
     record(input = "-xFE"),
     record(input = "10fE"),
     record(input = "0xFFFFFFFF"),
     record(input = "0x7FFFFFFFFFFFFFFF"),
     record(input = "0x8000000000000000"),
     record(input = "word"),
     record(input = " ")
| parse input, "HEXINT:result"

Configuration

Specify configuration parameters in parentheses after the matcher name: HEXINT(min=value, max=value):result.

Returns

The data type of the extracted value is long.

Basic example

Example: Match hex integer values against a range

The following pattern checks if a hex value is within the 16-bit unsigned range:

HEXINT(min=0, max=65535)

See how to use in DQL

data record(input = "0xa01F"),
     record(input = "10fE"),
     record(input = "-xFE")
| fieldsAdd result = matchesPattern(input, "HEXINT(min=0, max=65535)")

Practical example

Example: Parse a memory address value

Given the following input:

SIGSEGV at address 0x7ffd3a2c

Use the following pattern to extract the memory address:

'SIGSEGV at address ' HEXINT:address

See how to use in DQL

data record(input = "SIGSEGV at address 0x7ffd3a2c")
| parse input, "'SIGSEGV at address ' HEXINT:address"

LONG

Matches integral numbers in the form of [+|-]?[0-9]+ with values in the range -9223372036854775808 to 9223372036854775807.

Use the following pattern to parse long integer values:

LONG:result

For example, parsing long values including large numbers:

See how to use in DQL

data record(input = "-10"),
     record(input = "2.5"),
     record(input = "3,6"),
     record(input = "0xa01F"),
     record(input = "2147483647"),
     record(input = "2147483648"),
     record(input = "9223372036854775807"),
     record(input = "9223372036854775808"),
     record(input = " ")
| parse input, "LONG:result"

Configuration

Specify configuration parameters in parentheses after the matcher name: LONG(min=value, max=value):result.

Returns

The data type of the extracted value is long.

Basic example

Example: Match long values against a predefined range

The following pattern checks if a long value is non-negative:

LONG(min=0)

See how to use in DQL

data record(input = "9223372036854775807"),
     record(input = "-2000")
| fieldsAdd result = matchesPattern(input, "LONG(min=0)")

Practical example

Example: Parse a Unix timestamp value in milliseconds

Given the following input:

event id=1576590440679 type=login

Use the following pattern to extract the event identifier:

'event id=' LONG:id SPACE LD

See how to use in DQL

data record(input = "event id=1576590440679 type=login")
| parse input, "'event id=' LONG:id SPACE LD"

HEXLONG

Matches integral numbers in hexadecimal notation [+|-]?0?x?[0-9a-fA-F]+ with values in the range -9223372036854775808 to 9223372036854775807.

Use the following pattern to parse hexadecimal long values:

HEXLONG:result

For example, parsing hexadecimal long values in different notations:

See how to use in DQL

data record(input = "0xa01F"),
     record(input = "x3"),
     record(input = "-xFE"),
     record(input = "10fE"),
     record(input = "0xFFFFFFFF"),
     record(input = "0x7FFFFFFFFFFFFFFF"),
     record(input = "0x8000000000000000"),
     record(input = "word"),
     record(input = " ")
| parse input, "HEXLONG:result"

Configuration

Specify configuration parameters in parentheses after the matcher name: HEXLONG(min=value, max=value):result.

Returns

The data type of the extracted value is long.

Basic example

Example: Match hex long values against a range

The following pattern checks if a hex long value is non-negative:

HEXLONG(min=0)

See how to use in DQL

data record(input = "0xFFFFFFFFFFFFFF"),
     record(input = "10fE")
| fieldsAdd result = matchesPattern(input, "HEXLONG(min=0)")