FlinkCEP - Complex event processing for Flink
FlinkCEP is the complex event processing library for Flink. It allows you to easily detect complex event patterns in a stream of endless data. Complex events can then be constructed from matching sequences. This gives you the opportunity to quickly get hold of what’s really important in your data.
If you want to jump right in, you have to set up a Flink program.
Next, you have to add the FlinkCEP dependency to the
pom.xml of your project.
Note that FlinkCEP is currently not part of the binary distribution. See linking with it for cluster execution here.
Now you can start writing your first CEP program using the pattern API.
Note that we have used Java 8 lambdas here to make the example more succinct.
The Pattern API
The pattern API allows you to quickly define complex event patterns.
Each pattern consists of multiple stages or what we call states. In order to go from one state to the next, the user can specify conditions. These conditions can be the contiguity of events or a filter condition on an event.
Each pattern has to start with an initial state:
Each state must have an unique name to identify the matched events later on.
Additionally, we can specify a filter condition for the event to be accepted as the start event via the
We can also restrict the type of the accepted event to some subtype of the initial event type (here
Event) via the
As it can be seen here, the subtype condition can also be combined with an additional filter condition on the subtype.
In fact you can always provide multiple conditions by calling
subtype multiple times.
These conditions will then be combined using the logical AND operator.
Next, we can append further states to detect complex patterns. We can control the contiguity of two succeeding events to be accepted by the pattern.
Strict contiguity means that two matching events have to succeed directly.
This means that no other events can occur in between.
A strict contiguity pattern state can be created via the
Non-strict contiguity means that other events are allowed to occur in-between two matching events.
A non-strict contiguity pattern state can be created via the
It is also possible to define a temporal constraint for the pattern to be valid.
For example, one can define that a pattern should occur within 10 seconds via the
Defines a starting pattern state:
Appends a new pattern state. A matching event has to directly succeed the previous matching event:
Appends a new pattern state. Other events can occur between a matching event and the previous matching event:
Defines a filter condition for the current pattern state. Only if an event passes the filter, it can match the state:
Defines a subtype condition for the current pattern state. Only if an event is of this subtype, it can match the state:
Defines the maximum time interval for an event sequence to match the pattern. If a non-completed event sequence exceeds this time, it is discarded:
In order to run a stream of events against your pattern, you have to create a
Given an input stream
input and a pattern
pattern, you create the
PatternStream by calling
Selecting from Patterns
Once you have obtained a
PatternStream you can select from detected event sequences via the
select method requires a
PatternSelectFunction has a
select method which is called for each matching event sequence.
It receives a map of string/event pairs of the matched events.
The string is defined by the name of the state to which the event has been matched.
select method can return exactly one result.
PatternFlatSelectFunction is similar to the
PatternSelectFunction, with the only distinction that it can return an arbitrary number of results.
In order to do this, the
select method has an additional
Collector parameter which is used for the element output.
The following example detects the pattern
start, middle(name = "error") -> end(name = "critical") on a keyed data stream of
The events are keyed by their ids and a valid pattern has to occur within 10 seconds.
The whole processing is done with event time.