84.6. Temporal operators for events

This operator specifies if the current event occurs after the correlated event. This operator can also define an amount of time after which the current event can follow the correlated event, or a delimiting time range during which the current event can follow the correlated event.

For example, the following pattern matches if $eventA starts between 3 minutes and 30 seconds and 4 minutes after $eventB finishes. If $eventA starts earlier than 3 minutes and 30 seconds after $eventB finishes, or later than 4 minutes after $eventB finishes, then the pattern is not matched.

$eventA : EventA(this after[3m30s, 4m] $eventB)

You can also express this operator in the following way:

3m30s <= $eventA.startTimestamp - $eventB.endTimeStamp <= 4m

The after operator supports up to two parameter values:

The after operator also supports negative time ranges:

$eventA : EventA(this after[-3m30s, -2m] $eventB)

If the first value is greater than the second value, the decision engine automatically reverses them. For example, the following two patterns are interpreted by the decision engine in the same way:

$eventA : EventA(this after[-3m30s, -2m] $eventB)
$eventA : EventA(this after[-2m, -3m30s] $eventB)

This operator specifies if the current event occurs before the correlated event. This operator can also define an amount of time before which the current event can precede the correlated event, or a delimiting time range during which the current event can precede the correlated event.

For example, the following pattern matches if $eventA finishes between 3 minutes and 30 seconds and 4 minutes before $eventB starts. If $eventA finishes earlier than 3 minutes and 30 seconds before $eventB starts, or later than 4 minutes before $eventB starts, then the pattern is not matched.

$eventA : EventA(this before[3m30s, 4m] $eventB)

You can also express this operator in the following way:

3m30s <= $eventB.startTimestamp - $eventA.endTimeStamp <= 4m

The before operator supports up to two parameter values:

The before operator also supports negative time ranges:

$eventA : EventA(this before[-3m30s, -2m] $eventB)

If the first value is greater than the second value, the decision engine automatically reverses them. For example, the following two patterns are interpreted by the decision engine in the same way:

$eventA : EventA(this before[-3m30s, -2m] $eventB)
$eventA : EventA(this before[-2m, -3m30s] $eventB)

This operator specifies if the two events occur at the same time, with the same start and end times.

For example, the following pattern matches if both the start and end time stamps of $eventA and $eventB are identical:

$eventA : EventA(this coincides $eventB)

The coincides operator supports up to two parameter values for the distance between the event start and end times, if they are not identical:

The following pattern uses start and end time thresholds:

$eventA : EventA(this coincides[15s, 10s] $eventB)

The pattern matches if the following conditions are met:

abs($eventA.startTimestamp - $eventB.startTimestamp) <= 15s
&&
abs($eventA.endTimestamp - $eventB.endTimestamp) <= 10s

This operator specifies if the current event occurs within the time frame of when the correlated event starts and ends. The current event must start after the correlated event starts and must end before the correlated event ends. (With the coincides operator, the start and end times are the same or nearly the same.)

For example, the following pattern matches if $eventA starts after $eventB starts and ends before $eventB ends:

$eventA : EventA(this during $eventB)

You can also express this operator in the following way:

$eventB.startTimestamp < $eventA.startTimestamp <= $eventA.endTimestamp < $eventB.endTimestamp

The during operator supports one, two, or four optional parameters:

This operator specifies if the correlated event occurs within the time frame of when the current event occurs. The correlated event must start after the current event starts and must end before the current event ends. (The behavior of this operator is the reverse of the during operator behavior.)

For example, the following pattern matches if $eventB starts after $eventA starts and ends before $eventA ends:

$eventA : EventA(this includes $eventB)

You can also express this operator in the following way:

$eventA.startTimestamp < $eventB.startTimestamp <= $eventB.endTimestamp < $eventA.endTimestamp

The includes operator supports one, two, or four optional parameters:

This operator specifies if the current event starts after the correlated event but both events end at the same time.

For example, the following pattern matches if $eventA starts after $eventB starts and ends at the same time when $eventB ends:

$eventA : EventA(this finishes $eventB)

You can also express this operator in the following way:

$eventB.startTimestamp < $eventA.startTimestamp
&&
$eventA.endTimestamp == $eventB.endTimestamp

The finishes operator supports one optional parameter that sets the maximum time allowed between the end times of the two events:

$eventA : EventA(this finishes[5s] $eventB)

This pattern matches if these conditions are met:

$eventB.startTimestamp < $eventA.startTimestamp
&&
abs($eventA.endTimestamp - $eventB.endTimestamp) <= 5s

This operator specifies if the correlated event starts after the current event but both events end at the same time. (The behavior of this operator is the reverse of the finishes operator behavior.)

For example, the following pattern matches if $eventB starts after $eventA starts and ends at the same time when $eventA ends:

$eventA : EventA(this finishedby $eventB)

You can also express this operator in the following way:

$eventA.startTimestamp < $eventB.startTimestamp
&&
$eventA.endTimestamp == $eventB.endTimestamp

The finished by operator supports one optional parameter that sets the maximum time allowed between the end times of the two events:

$eventA : EventA(this finishedby[5s] $eventB)

This pattern matches if these conditions are met:

$eventA.startTimestamp < $eventB.startTimestamp
&&
abs($eventA.endTimestamp - $eventB.endTimestamp) <= 5s

This operator specifies if the current event ends at the same time when the correlated event starts.

For example, the following pattern matches if $eventA ends at the same time when $eventB starts:

$eventA : EventA(this meets $eventB)

You can also express this operator in the following way:

abs($eventB.startTimestamp - $eventA.endTimestamp) == 0

The meets operator supports one optional parameter that sets the maximum time allowed between the end time of the current event and the start time of the correlated event:

$eventA : EventA(this meets[5s] $eventB)

This pattern matches if these conditions are met:

abs($eventB.startTimestamp - $eventA.endTimestamp) <= 5s

This operator specifies if the correlated event ends at the same time when the current event starts. (The behavior of this operator is the reverse of the meets operator behavior.)

For example, the following pattern matches if $eventB ends at the same time when $eventA starts:

$eventA : EventA(this metby $eventB)

You can also express this operator in the following way:

abs($eventA.startTimestamp - $eventB.endTimestamp) == 0

The met by operator supports one optional parameter that sets the maximum distance between the end time of the correlated event and the start time of the current event:

$eventA : EventA(this metby[5s] $eventB)

This pattern matches if these conditions are met:

abs($eventA.startTimestamp - $eventB.endTimestamp) <= 5s

This operator specifies if the current event starts before the correlated event starts and it ends during the time frame that the correlated event occurs. The current event must end between the start and end times of the correlated event.

For example, the following pattern matches if $eventA starts before $eventB starts and then ends while $eventB occurs, before $eventB ends:

$eventA : EventA(this overlaps $eventB)

The overlaps operator supports up to two parameters:

This operator specifies if the correlated event starts before the current event starts and it ends during the time frame that the current event occurs. The correlated event must end between the start and end times of the current event. (The behavior of this operator is the reverse of the overlaps operator behavior.)

For example, the following pattern matches if $eventB starts before $eventA starts and then ends while $eventA occurs, before $eventA ends:

$eventA : EventA(this overlappedby $eventB)

The overlapped by operator supports up to two parameters:

This operator specifies if the two events start at the same time but the current event ends before the correlated event ends.

For example, the following pattern matches if $eventA and $eventB start at the same time, and $eventA ends before $eventB ends:

$eventA : EventA(this starts $eventB)

You can also express this operator in the following way:

$eventA.startTimestamp == $eventB.startTimestamp
&&
$eventA.endTimestamp < $eventB.endTimestamp

The starts operator supports one optional parameter that sets the maximum distance between the start times of the two events:

$eventA : EventA(this starts[5s] $eventB)

This pattern matches if these conditions are met:

abs($eventA.startTimestamp - $eventB.startTimestamp) <= 5s
&&
$eventA.endTimestamp < $eventB.endTimestamp

This operator specifies if the two events start at the same time but the correlated event ends before the current event ends. (The behavior of this operator is the reverse of the starts operator behavior.)

For example, the following pattern matches if $eventA and $eventB start at the same time, and $eventB ends before $eventA ends:

$eventA : EventA(this startedby $eventB)

You can also express this operator in the following way:

$eventA.startTimestamp == $eventB.startTimestamp
&&
$eventA.endTimestamp > $eventB.endTimestamp

The started by operator supports one optional parameter that sets the maximum distance between the start times of the two events:

$eventA : EventA( this starts[5s] $eventB)

This pattern matches if these conditions are met:

abs( $eventA.startTimestamp - $eventB.startTimestamp ) <= 5s
&&
$eventA.endTimestamp > $eventB.endTimestamp