Breakup

The Breakup Stage is used to split an event value into multiple events.

Breakup Type

Break-up operation to perform on the event value. Array, Object, and All are supported.

Array

Split array value types into N events that contain a single scalar each. This operates on arrays of simple and complex types. Upon breakup, the stage sets event.metadata.breakupIndex to the array index of the value. An example Array Breakup operation is shown below. Continuously nested arrays can be broken up by setting a depth greater than one.

Depth

Defines how deep the break-up operation should traverse within the payload. This setting is particularly useful for deeply nested structures, such as multi-dimensional arrays or complex objects.

If the specified depth is deeper than the payload’s structure, the operation will continue breaking it up until there’s nothing left to break up.

Example Input Event Value

[{
    "a": 1,
    "b": 2,
    "c": 3
}, {
    "a": 10,
    "b": 20,
    "c": 30
}, {
    "a": 200,
    "b": 200,
    "c": 300
}]

Example Output Event Values

{
 "a": 1,
 "b": 2,
 "c": 3
}

{
 "breakupIndex": 0,
 "breakupPath": "0"
}

{
 "a": 10,
 "b": 20,
 "c": 30
}

{
 "breakupIndex": 1,
 "breakupPath": "1"
}

{
 "a": 200,
 "b": 200,
 "c": 300
}

{
 "breakupIndex": 2,
 "breakupPath": "2"
}

Object

Split a complex value into N event values containing the values from each of its attributes. Upon breakup, the stage sets event.metadata.breakupName to the name of the attribute associated with the value. An example Object Breakup operation is shown below. Continuously nested objects can be broken up by setting a depth greater than one.

Example Input Event Value

{
 "a": 1,
 "b": 2,
 "c": 3
}

Example Output Event Values

1

{
 "breakupName": "a",
 "breakupPath": "a"
}

2

{
 "breakupName": "b",
 "breakupPath": "b"
}

3

{
 "breakupName": "c",
 "breakupPath": "c"
}

All

In this mode, if the event value is an array, it follows the array breakup example. If the event is an object, it follows the object example. When configured with a depth greater than one, the value will be recursively broken up.

Example Input Event Value

{
 "a": [1,2,3],
 "b": {
        "childOne": "valueOne",
        "childTwo": "valueTwo"
 },
 "c": [
        {
                "deepChild": "deepValue"
        }
 ]
}

Example Output Event Values

1

{
 "breakupIndex": 0,
 "breakupPath": "a/0"
}

2

{
 "breakupIndex": 1,
 "breakupPath": "a/1"
}

3

{
 "breakupIndex": 2,
 "breakupPath": "a/2"
}

"valueOne"

{
 "breakupName": "b/childOne",
 "breakupPath": "b/childOne"
}

"valueTwo"

{
 "breakupName": "b/childTwo",
 "breakupPath": "b/childTwo"
}

"deepValue"

{
 "breakupName": "deepChild",
 "breakupPath": "c/0/deepChild"
}