Introduction

Core Concepts

Atlas Connex is a robust and reliable data routing platform for engineers, which empowers you to bridge applications without the overhead of building and maintaining an event management system. Using our low-code/no-code platform, you can filter, transform, and control the flow of events to their destinations. Atlas provides highly configurable event queues, including automatic retry, rate limiting, detailed logging, and development tools, enabling you to focus on building the automation that’s important to your business.

What can you do with Atlas Connex?

Atlas provides the ability to accept data from any Source type, massage that data, format, filter, and deliver it to any Destination type, without building any infrastructure to support this flow. Configurable and managed event queues with on-demand pausing and throttling for individual destinations means your data flow is highly reliable and can stand up to unforeseen downtime and maintenance without missing a beat. Detailed logging for each phase of the fan-out (or fan-in) from source to destination provides the breadcrumbs for investigation when things go wrong.

The Basics

At the heart of the Atlas platform are a few core concepts. Simply put, Sources are entry points into the Atlas routing system. By sending data to a Source, an Event is created. Based on the Route you define, the Payload associated with this Event is fanned out through Filters which can modify the Payload, or decide to drop it entirely. When the filtering is complete, the routing system will deliver this Payload to your Destination(s). If it cannot be delivered, the Event is queued for later delivery.

Definitions

Sources

Sources are data entrypoints with a unique ID and one or more key/secret pairs. A Source can be fanned out to one or more Destinations. These Sources can be HTTP requests like webhooks, MQTT topics, polled API endpoints, and many more types of data sources. Check out the Sources page for more info. If you have a request for a particular type of Source, send us a note and we will follow up! Check out our roadmap for the source types which are currently being implemented.

Source
Source

Filters

Filters are optional intermediate handlers sitting between Sources and Destinations. Filters perform their action by executing user-desgined, Python-based functionality which is edited in the web console. The Filter language is Python and has many built-ins to simplify common actions like JSON to XML conversion, date comparison, string parsing and other capabilities.


#######################################################
# Filter Example: JSON-to-XML conversion
# Description: This filter is a basic 
# converter of JSON payloads to an
# XML payload. This example uses three
# Atlas utility classes XMLElement, Type,
# and JSON. For documentation on the
# available Filter utilities, see 
# https://docs.atlasconnex.com/filters/#utilities
#######################################################

def run(payload):
    # convert the incoming payload to JSON
    # will return None if it can't be converted
    obj = JSON.parse(payload["data"]["body"])

    # create our root element for the XML
    xRoot = XMLElement("root")
    
    # define a recursive capability taking:
    # - o: a dict object
    # - p: the XMLElement parent object
    def recurse(o, p):
        if o is None:
            return
        # iterate the object and recurse if the values
        # are dicts themselves
        for k, v in o.items():
            xChild = XMLElement(k)
            if Type.is_dict(v):
                recurse(v, xChild)
            elif Type.is_list(v):
                # if it's a list, don't recurse, but "list-ize" the values
                # this can be modified to suit the XML syntax for arrays
                # you expect, but as a default it generates numbered elements
                # for example:
                # {"an-array":["cats", "dogs"]} turns into 
                # <an-array>
                # <an-array0>cats</an-array0>
                # <an-array1>dogs</an-array1>
                # </an-array>
                i = 0
                for val in v:
                    xListItem = XMLElement(f"{k}{i}", val)
                    xChild.add_child(xListItem)
                    i = i + 1
            else:
                # if it's just a string, number, or null, just assign it
                xChild.value = str(v)
            # add a child
            p.add_child(xChild)
        
    recurse(obj, xRoot)
    payload["data"]["body"] = str(xRoot)
    return payload

Destinations

Destinations are the final stop on a Route. The Destination configuration determines how Atlas attempts to deliver the Payload it has been given. Destinations can be HTTP endpoints, MQTT topics, and many more destination types. Check out the Destinations page for more info and a listing of the currently supported Destination types. If you have a request for a particular type of Destination, send us a note and we will follow up!

Destination
Destination

Routes

Routes are simply a graph showing how an Event will fan out to one or more Destinations, and which (if any) Filters will be used along the way.

Route Fan-out Example
Route Fan-out Example

Events

Events are generated whenever data is received at a Source. Each event has a unique ID which identifies the log entry in the Atlas Connex platform. The event data (the Payload) is routed through the system as defined by your route, and is optionally modified until it is finally delivered (or queued) at a Destination.

Questions, clarification, or incorrect info? Send us mail!

Auto-generated Thu 14 Apr 2022 08:06:50 PM CDT