Lambda Expressions

TICKscript uses lambda expressions to define transformations on data points as well as define boolean conditions that act as filters. TICKscript tries to be similar to InfluxQL in that most expressions that you would use in an InfluxQL WHERE clause will work as expressions in TICKscript. There are few exceptions:

• All field or tag identifiers must be double quoted.
• The comparison operator for equality is == not =.

All expressions in TICKscript begin with the lambda: keyword.

.where(lambda: "host" == 'server001.example.com')

Stateful

These lambda expressions are stateful, meaning that each time they are evaluated internal state can change and will persist until the next evaluation. This may seem odd as part of an expression language but it has a powerful use case. You can define a function within the language that is essentially a online/streaming algorithm and with each call the function state is updated. For example the built-in function sigma that calculates a running mean and standard deviation and returns the number of standard deviations the current data point is away from the mean.

Example:

sigma("value") > 3

Each time that the expression is evaluated the new value it updates the running statistics and then returns the deviation. This simple expression evaluates to false while the stream of data points it has received remains within 3 standard deviations of the running mean. As soon as a value is processed that is more than 3 standard deviation it evaluates to true. Now you can use that expression inside of a TICKscript to define powerful alerts.

TICKscript with lambda expression:

stream
    |alert()
        // use an expression to define when an alert should go critical.
        .crit(lambda: sigma("value") > 3)

Builtin Functions

Type Conversion functions

Bool

Converts a string into a boolean via Go’s strconv.ParseBool function. Numeric types can also be converted to a bool where a 0 -> false and 1 -> true.

bool(value) bool

Int

Converts a string or float64 into an int64 via Go’s strconv.ParseInt or simple float64() coercion. Strings are assumed to be decimal numbers. Durations are converted into an int64 with nanoseconds units. A boolean is converted to an int64 where false -> 0 and true -> 1.

int(value) int64

Float

Converts a string or int64 into an float64 via Go’s strconv.ParseFloat or simple int64() coercion. A boolean is converted to an float64 where false -> 0.0 and true -> 1.0.

float(value) float64

String

Converts a bool, int64 or float64 into an string via Go’s strconv.Format* functions. Durations are converted to a string representation of the duration.

string(value) string

Duration

Converts a int64 or float64 into an duration assuming nanoseconds units. Strings are converted to duration of the form as duration literals in TICKscript.

duration(value) duration

Stateful Functions

Sigma

Computes the number of standard deviations a given value is away from the running mean. Each time the expression is evaluated the running mean and standard deviation are updated.

sigma(value float64) float64

Count

Count takes no arguments but returns the number of times the expression has been evaluated.

count() int64

Time functions

Within each expression the time field contains the time of the current data point. The following functions can be used on the time field. Each function returns an int64.

Example usage:

lambda: hour("time") == 9

The above expression evaluates to true if the hour of the day for the data point is 9 AM, using local time.

Math functions

The following mathematical functions are available. Each function is implemented via the equivalent Go function. Short descriptions are provided here but see the Go docs for more details.

Human String functions

HumanBytes

Converts a int64 or float64 with units bytes into a human readable string representing the number of bytes.

humanBytes(value) string

Conditional Functions

If

Returns the result of its operands depending on the value of the first argument. The second and third arguments must return the same type.

Example:

|eval(lambda: if("field" > threshold AND "field" != 0, 'true', 'false'))
    .as('value')

The value of the field value in the above example will be the string true or false, depending on the condition passed as the first argument.

The if function’s return type is the same type as its second and third arguments.

if(condition, true expression, false expression)