Competing ESP solutions help you navigate rushing rivers of information

In simpler times, early stream-monitoring apps took months to crank out and didn’t easily scale for reuse outside their initial scope.

Today two top-tier products, Progress Apama 2.4 from Progress Software and StreamBase 3.5 from StreamBase Systems, are altering the ESP (event stream processing) landscape. By improving operational insight and automated response — in finance, health care, or general SOA infrastructure monitoring, for example — both solutions can be used to quickly develop apps for building up event correlation out of a flood of enterprise data.

Compared with slower traditional BAM (business activity monitoring), ESP allows you to pull historic data from back-office sources; but its forte is working on data in real time without delays. It offers additional power by detecting missed events, scanning for what didn’t happen, rather than just reporting on what already did.

Although their aims are the same, these two products take decidedly different tacks. The Progress solution inherited a rules-driven approach from the company’s acquisition of Apama: It uses state diagrams and rules composition to generate native applications. In contrast, StreamBase’s Java platform employs visual flow diagramming and its own StreamSQL — a SQL derivative amended for live, time-centric queries on event streams.

StreamBase’s Eclipse IDE makes drag-and-drop stream development quick and easy, and it’s well integrated with simulation testing tools. I was less impressed by the solution’s server administration and its limited adapter set, however, as compared with Apama. StreamBase’s new JMS/EMS adapter is a step in the right direction. The newly added StreamSQL editor also offered strong usability features for direct coding in the native language.

Click for larger view.

Apama’s capabilities do not extend much beyond the product’s original trading focus, and development is not quite as easy as with StreamBase or other rules-centric products such as AptSoft Director for CEP. It offers no code editor similar to the one found in StreamBase or iSpheres EPL Studio. Admittedly, the push today is to hide complexity, but there are times when direct access is just easier.

Apama’s capabilities, however, are rich, and its applications aggregate and process data streams well. Included tools — such as the Dashboard Wizard for easy client creation and additional packages for simulation testing and distributed administration — go a long way toward building up the product’s enterprise credibility.

Neither solution can import from external modeling tools, nor does either offer higher-level impact analysis like Tibco BusinessEvents. Both need to improve areas such as integrated process monitoring, both at run time and during simulation. But this remains an emerging field, and vendors are still grappling with approaches and a lack of standards.

Stream catcher

The essential system components from both vendors consist of a core runtime engine for processing and correlating events in memory, and a visual IDE used to piece together apps.

StreamBase Studio modeler defines schemas on streams and visually connects components into flows with filters, data maps, and stream routing. Managing variables and data queries proved easy in my testing, and storage tables were a snap to set up and access.

The new StreamSQL editor allowed me to create modules by hand with productivity-boosting features such as code assist and parameter hinting. Although I’d prefer to see auto-completion rather than user-initiated pop-ups, the result assists developers in learning StreamSQL. StreamBase provides a conversion utility for translating flow-based apps to editable StreamSQL, but a better one-to-one relationship between apps and underlying code would iron out some of the compatibility creases moving between the two.

Part of the Apama suite of tools, Event Modeler Professional Edition includes Scenario Manager, a rules-based IDE and graphical state mapper that ties states and transitions to conditions and actions within rule definitions.

Although I could build up rules using the fly-out menu palettes, which showed only relevant variables and actions for my immediate focus, I found it cumbersome. I don’t mean to suggest Apama was not ultimately capable and effective in its purpose. I only wish for a more manageable interface that simplified rules development, management, and ultimately, comprehension, as rule sets grew unwieldy.

Click for larger view.

In its favor, Apama’s approach does ensure valid rule creation, and its state/rule sync between development panels enhanced navigation.

Both vendors showed solid features for aggregating data sets, managing time windows, filtering, and modifying event payloads in flight.

Although both offer good access to finance and statistical functions, I found StreamBase to deliver better all-around string and date manipulation features. StreamBase also has a useful function for exception catching, so division by zero, for example, won’t crash your engine.

Apama’s Dashboard Wizard jump-starts JSP client interfaces, although it can only deliver and update text tables. For graphical heads-up, you’ll want to use the full Dashboard Studio, a separate IDE for data binding the included collections of widgets: charts (many stock-specific), tables, graphs, and meters.

Apama’s incomplete documentation and lack of help facilities disappointed me, in stark contrast to StreamBase’s abundant reference materials and tutorials. For my money, I want my team going in with more support than the generic, PDF overviews provided with Apama.

To the test

StreamBase Studio well-integrated simulation testing enabled me to feed historic simulation data into my application for playback. I was able to use the onboard recorder to save live streams for later use, make manual changes into event payloads (good for testing isolated issues), and use the included data randomizer to generate continuous loops of parameterized test data. StreamBase also offers an add-on, StreamBase Chronicle, capable of storing terabytes of event stream info for later recall.

StreamBase’s command-line debug mode provides basic break points, operation stepping, and log review, but I’d rather see it brought up to par with the rest of the visual tools. In contrast, Apama’s additional Research Studio showed more detailed insight and control during testing.

Apama’s process for deployment and simulation testing, however, is somewhat less integrated. Within the modeler, I had to package up scenario and dashboard scripts, fire up the localized event-monitor engine, start a separate Deployment Tool to inject requisite support files and simulation scripts, bring up a Web browser to deploy my app, and then, finally, begin testing.

In fairness, most of the steps outlined above are mere one-click operations, and this release now auto-loads application-dependent service monitors. Although separate tools can benefit distributed dev environments, the entire process should also be streamlined directly into the Windows IDE.

Apama’s native debugging capabilities were mediocre, but a companion app — EventStore 2.4 with its Research Studio — adds some enterprise-rich features.

EventStore maintains running collections of live event data, without impact to throughput, and syncs a design-time replica for use in testing. Research Studio is able to isolate specific event groups and time frames, simulate event-only data, and run complete historic playbacks with timing information and external stream feeds. This can go a long way toward failure analysis and back testing.

Wading in data

Both vendors provide some semblance of load balancing and availability assurance. Apama’s low-latency options can accelerate queue management processing, and its channel routers can push a stream across a predefined channel for processing on an alternate engine.

StreamBase supports clustering and load balancing as well. At dev time, however, you simply need to select concurrency for a module. Work is automatically distributed among available processors, or configured cluster farm.

Both offer fail-over features. Apama checkpoints are only available through the Enterprise Management and Monitoring console, which must remain running. But it can restart engines using the most recent checkpoint and can be used to manage interface adapters and routers as well.

StreamBase runs checkpoints for recovery, too, but high availability cannot be run concurrently with its cluster mode.

For truly mission-critical applications, the gap between checkpoints may not be sufficient for transactional reliability. You’ll still need to incorporate hand-coded synchronization routines within your client apps.

Downstream

Although stream processing isn’t new, it hasn’t fully evolved. In the future, ESP systems must develop facilities that more innately finesse complex correlations out of event clouds. Although StreamBase at least exposes time as a native data type, for example, future iterations must expand to handle causality among events and offer easy relationship algorithms beyond mere temporal reference in order to simplify truly complex event processing.

But we’ve come a long way in the quest to monitor and streamline operations. For quick development — without sacrifice to long-term flexibility — both Apama and StreamBase lay solid groundwork that will help companies manually glean meaning from complex streams and begin capitalizing on automated, real-time awareness and response.