Fabrique Nodes
Fabrique Nodes is a no-code, cloud native, scalable, online event processing service for event-driven applications such as decision automation, real-time analytics, anomaly detection, complex event processing, AI implementation, data integration and enrichment without programming skills.
Event processing logic is built by the extendable collection of no-code Nodes, forming the directed asynchronous computational graph of operations. Fabrique.ai Node Editor allows to create complex event processing scenarios and move projects to production in 1 click.
.jpg)
Basic Scenarios
Nodes provide an intuitive way to create, maintain, re-use, expand, and share processing logic for common scenarios such as event collection, enrichment, mapping, sorting, joining, filtering, aggregation, validation, error handling, “wave” counting, anomaly detection, actual to regular comparison, alerting, generating, rule and ML based decision making etc.
Node Collection
Nodes are the basic operations allowing to consume messages from cloud PubSub services; request / respond REST API; process semi-structured data; compose / decompose nested structures; extract / pack elements of arrays; collect windows, dictionaries; check conditions; make calculations; trigger events; generate messages; deliver results to destinations etc.
Structural Nodes
.png)
Gets an array of elements to the input Port, decomposes elements, sends the elements one by one to the output Port.
Gets an array of elements to the input Port, applies a group operation to the elements, sends the array to the output Port.
Gets an element by element to the input Port, composes elements to an array, sends the array to the output Port.
Gets nested object to the input Port, decomposes elements from the object, sends the elements to the output Ports
Gets elements to the input Ports, composes an object from the elements, sends the object to the output Port.
Modifying Nodes
.png)
Gets a trigger and parameters to the input Ports, requests REST API, deletes data from the REST API service.
.png)
Gets a trigger to the input Port, declares values of elements, objects, or arrays, and sends the values to the output Ports
.png)
Gets a trigger and parameters to the input Ports, requests REST API, requests data from the REST API service.
.png)
Gets String data to the input Port, applies patterns, extracts parts of the string, sends the parts to the output Ports.
.png)
Gets a trigger and parameters to the input Ports, requests REST API, posts data to the REST API service.
.png)
Gets data of one type to the input Port, modifies the type of data, sends modified data to the output Port.
.png)
Gets a trigger and parameters to the input Ports, requests REST API, modifies data in the REST API service.
Stateful Nodes
.png)
Gets a key to the input Port, requests a collection of key-value pairs, deletes the key-value pair, returns a confirmation of deletion.
.png)
Gets a key to the input Port, requests a collection of key-value pairs, gets a value for the key, sends the value to the output Port.
.png)
Gets a key-value pair to the input Port, requests a collection of key-value pairs, writes key-value pair to the collection, returns a confirmation of writing.
.png)
Gets timestamp, key, and value to the input Ports, applies a window aggregation function, stores the aggregate to a collection.
.png)
Gets timestamp and key to the input Ports, requests window aggregates from a collection, sends aggregates to the output Ports.
Conditional Nodes
.png)
Gets elements to the first and condition to the second input group of Ports, transmits elements to the output group of Ports if condition “is true”.
.png)
Gets elements and condition to the input group of Ports, transmits elements to the output “if condition” group of Ports if condition “is true”, otherwise to the output “else”.
Functional Nodes
.png)
Gets values of variables to the input Ports, applies functions from a collection to the variables, sends results of the functions to the output Ports.
.png)
Gets a trigger to the input Port, applies random functions from a collection to generate values, sends values to the output Ports.
InOut Nodes
.png)
Reads JSON messages from an input Topic, deserialises JSON messages, decomposes JSON objects to elements (except arrays), sends elements to the output Ports.
.png)
Gets elements from input Nodes, composes elements to JSON objects (except arrays), serialises JSON messages, writes JSON messages to the output Topic.
.png)
Connects to AWS SQS PubSub service, subscribes to a Queue, consumes JSON messages, deserialise JSON messages, decomposes JSON objects to elements (except arrays), sends elements to the output Ports.
.png)
Gets elements to the input Ports, composes elements to JSON objects (except arrays), serialises JSON messages, connects to AWS SQS PubSub service, publishes JSON messages to a Queue.
.png)
Triggers periodically events with a timestamp to the output Port.
Nodes are connected by Ports & Links
Note!
All Port have to be connected, hidden, or deleted. Unlinked Ports are not allowed.
Step by Step
-
The "JSONin" Node reads input JSON files, deserialises, decomposes objects to elements, defines data types, transmits values of the elements to the output Ports.
-
The "Array To Element" Node gets the values of "array", "object.name", and "ts" to the input Ports, iterates "array", extracts "elements" from "array", and sends "elements" one by one to the output "element" Port. The elements "object.name" and "ts" are transmitted without any change.
-
The "JSONout" Node gets elements to the input Ports, composes elements to JSON message, serialises message, and writes to the output.
Nodes have input and output Ports as well as configurational parameters. Ports allow linking Nodes with each other to build computational graphs of operations on the level of elements of data structures.
Ports get values of elements (objects, arrays, strings, numbers,..) to the input groups, apply transformations to the elements (calculate formulas, check conditions, iterate arrays, decompose objects, change data types, etc), and transmit results to the output groups.
Links connect output Ports of one Node with input Ports of other Nodes to transmit values of elements.
Linked Nodes form an Actor
Actor is a directed acyclic synchronous computational graph of operations built by linked Nodes.
Actor atomises and isolates one graph of linked Nodes from another.
Step by Step
-
"Timer" periodically generates events to the output and triggers the "Constants", and "WindowRead" Nodes.
-
"Constants" gets trigger, declares an empty array, and sends the array to the output.
-
"Array To Element" gets "array" and the value of "ts" to the input, extracts elements "A", "B", "C", "D", and requests the "WindowRead" Nodes.
-
The "WindowRead" Nodes requests 4 collections of window aggregates and sends values of 2 time windows to the outputs.
-
"Structurer" gets the values of the elements of the array and collects the window aggregates for each value.
-
"Element To Array"gets aggregates for each value as elements and composes to an array.
-
"JSONout" gets window aggregates from the "WindowRead" Nodes and the array from the "Element To Array" Node", composes elements to a JSON message, serialises message, and sends to the output.
Actors are connected by Topics and States
Topics and States extend Actors to build directed asynchronous computational graphs of operations. Directed cycles are permitted.
Topics transmit messages from Actor to Actor. Actors having the InOut Nodes get messages from input Topics and send results to output Topics. The processed messages are deleted.
States collect dictionaries and window aggregates. Actors having the Stateful Nodes reads collections from States and write collections to States. The collections have limits and retention.
Note!
Fabrique.ai keeps both Topics and States in memory. No data is persisted by default on backend.
Step by Step
-
The "ArrayToItem" Actor reads messages from the "Messages" Topic, executes a graph of Nodes, and writes results to the "Items" Topic.
-
The "Split XUZ vs ZYX" actor reads messages from the "Items" Topic, splits messages to the output sub-flows, and writes the messages to the "XYZ" and "ZYX" Topics respectively.
-
The "Count XYZ" Actor reads messages from the "XYZ" Topic, and collects window aggregates to the named State.
-
The "Count ZYX" Actor reads messages from the "XYZ" Topic, and collects window aggregates to another named State.
Nodes, Actors, Topics, States form a Project
.png)
Input Messages
.png)
Output Results
.png)
Project Step by Step
-
The “SQS Read” Actor connects to the AWS SQS PubSub service and consumes JSON messages from a Queue.
-
The consumed messages are sent to the “Messages” Topic.
-
The JSON messages have a nested element “object”, which takes 2 values "XYZ" or "ZYX". The “array” has a variable number of elements, having a pair of “item” taking 4 values “A”, “B”, “C”, D” and a “value” taking some integer number.
-
The “ArrayToItem” Actor consumes JSON Messages from the “Messages” Topic, extracts the “items” and “values” from the “array”, extracts “name” from the “object”, and composes a new message for each “item”.
-
The new JSON messages are stored to the “Items” Topic.
-
The “Split XYZ vs ZYX” Actor consumes JSON messages from the “Items” Topic, checks condition, and split the input flow into 2 sub-flows: if the “name” has “XYZ” value sends messages to the “XYZ” Topic, otherwise to the “ZYX” Topic.
-
The sub-flows are stored to the “XYZ” and “ZYX” Topics respectively.
-
The “Count XYZ” and “Count ZYX” Actors collect aggregates for the total number of messages and the SUM of “values” for each “item” in the each sub-flow separately.
-
The “Aggregator” Actor requests aggregates for “XYZ” and “ZYX”, composes a new JSON message, and stores to the “Aggregates” Topic.
-
The “SQS Write” Actor consumes the aggregates from the “Aggregates” Topic and sends results to a Queue in the AWS SQS PubSub service.
-
The results of the processing can be taken from the “Aggregates” Topic.
-
The Project counted the number of messages having “name” “XYZ” and “ZYX” as well as the SUM of “values” for each “item” within two 10-second windows.