Apama (software)

Applications for Apama are authored in the Event Processing Language (EPL). EPL contains language features designed purely for Event Driven Programming,[20] including:

• Events - Simple data structures containing fields and actions
• Monitors - Similar to classes in other languages, monitors contain listeners and actions and are loaded upon injection
• Listeners - Declarative patterns defining interesting conditions/combinations of events. Aggregation, temporal and filtering operators are supported
• Actions - Imperative functions, usually run by listeners upon activation or monitors upon load
• Contexts - Similar to threads, monitors exist inside contexts
• Channels - Mechanism for communicating between contexts and external systems
• Streams - Ordered partitions of events with support for aggregation and SQL-like queries

The EPL C++/Java-like syntax is designed to create CEP applications succinctly in conjunction with the above features, an example of which can be found below:

event MyEvent {
    integer myInt;
    sequence<string> myListOfStrings;
    boolean myBool;
}
 
monitor MyMonitor {
    action onload() {
        spawn worker() to context("mySideThread");
    }
 
    action worker() {
        on all MyEvent(myInt>10) as myCoassignedEvent -> MyEvent(myInt>20) or MyEvent(myBool=true) within 30.0 {
            if(doWork(myCoassignedEvent.myListOfStrings) != true) {
                log "Problem!";
            }
        }
    }
 
    action doWork(sequence<string>) returns boolean {
        // do work on the list
        return true;
    }
}

Apama Queries is an alternate language for creating rules over defined data sets, such as the past five minutes of received data or past twenty events received, in an automatically multi-threaded environment that scales across machines. Apama Queries are better suited for monitoring very large sets, such as bank transactions. Typically, each entity (i.e. account holder) will be partitioned and processed independently of the rest of the set. Queries and Monitors can communicate via channels. An example of the previous scenario can be found below:

query FindSuspiciousWithdrawals {
    parameters {
        float DURATION;
        float THRESHOLD;
    }
 
    inputs {
        Withdrawal() key cardNumber within DURATION;
    }
 
    find every Withdrawal as w
        where w.amount > 100
        select last(w.transactionId) as tid
        select last(w.cardNumber) as cid
        having last(w.amount) > THRESHOLD * avg(w.amount) {
            send SuspiciousTransaction(tid, cid) to SuspiciousTransactionManager;
        }
}

The Software AG Designer is an Eclipse based IDE with special support for developing and deploying Apama applications, which is included in a standard installation. Features include code assistance, package management, profiling, GUI development and deployment management.

Apama supports the ability for users to create plugins to extend capability. These plugins come in two forms, EPL plugins (to add features to EPL) and Connectivity plugins (for communicating with the outside world). C++ and Java APIs are available for both plugin types. Connectivity plugins come in two forms, codecs (which translate data from one format to another, such as the internal Apama representation to JSON) and transports (which handle sending/receiving to/from external systems, such as JMS). Connections to external systems are made by composing chains of codecs and one transport to achieve the desired topology; these connections are defined by a YAML configuration file at start-up or through dynamic management with the provided tools. Several pre-built plugins for popular technologies (e.g. R, MQTT, Kafka, HTTP, MatLab) as well as connectivity to other Software AG products (e.g. Universal Messaging, Terracotta, Cumulocity) are shipped with Apama installations.

The Apama process is entirely in memory and supports an optional SQLite based in-built persistence system. Additionally, the connectivity API supports reliable messaging to systems that support it, such as JMS. Finally, a pre-built distributed memory store plugin is provided with standard installations for use with appropriate back-ends.

Apama provides an in-built dashboarding technology developed from within the Software AG Designer, as well as native connections to Software AG's MashZone NextGen.