ScaleOut StreamServer™

  • Perform stateful stream processing on incoming events for deep introspection and real-time feedback.
  • Use an integrated in-memory data grid / stream processing engine to build "digital twins" of data sources.

Use Stateful Stream Processing for Deep Introspection

ScaleOut StreamServer™ combines a scalable, stream-processing compute engine with an integrated, in-memory data grid (IMDG) into a powerful, unified software platform for stateful stream processing. Now you can perform lightning-fast event analysis using sophisticated in-memory state tracking to provide deep introspection and precise real-time feedback. Ideal for a wide range of applications, including the Internet of Things (IoT), manufacturing, logistics, and financial services. ScaleOut StreamServer introduces breakthrough technology for the next generation in stream processing.

In a recent benchmark for a cable TV provider, ScaleOut StreamServer reduced the time required to correlate, cleanse, and analyze continuous telemetry for 10 million simulated set-top boxes from 6 hours to less than a second while handling more than 30K events per second.


See how ScaleOut StreamServer can be used to implement a real-time recommendation engine for e-commerce, analyzing clickstream data from hundreds of thousands of simultaneous shoppers and offering highly relevant, context-based recommendations in less than 200 milliseconds.


Stateful Stream Processing

Stateful Stream Processing for Deep Introspection

Live systems generate streams of incoming events that need to be tracked, correlated, and analyzed to identify patterns and trends — and then generate immediate feedback and alerts to steer operations.

With today’s ever more complex real-time systems, it’s not enough to just analyze patterns within data streams using conventional techniques. Applications need deeper introspection to extract full value from the telemetry they receive. They need to build dynamic models of data sources that they can continu­ously update and analyze. Called stateful stream processing and popularized as the “digital twin” by Gartner, this breakthrough approach can harness machine learning, neural networks, and other advanced techniques to enable deep introspection and provide precise, timely feedback for live systems.

To illustrate the power of stateful stream processing with ScaleOut StreamServer’s architecture, consider a heart-rate monitoring application which receives telemetry from wearable devices. ScaleOut StreamServer can route millions of incoming events to dynamic, in-memory models (“digital twins”) which track each patient’s unique medical history and current condi­tion, analyzing events and generating timely alerts to medical professionals when needed. Unlike traditional, “stateless” stream processing, which just examines incoming telemetry, ScaleOut StateServer analyzes telemetry in the context of state information regarding the data sources. For medical monitoring, this state information could include medical history, current medications, recent medical events, patient activity, and much more. The result is deeper introspection and more timely, effective feedback and alerting.

Illustration of Stateful Stream Processing for a Medical Monitoring Application

Wide Range of Applications

Stateful stream processing can dramatically improve the quality of real-time feedback for virtually any stream processing application. Here are just a few examples:

  • Financial services: portfolio tracking, wire fraud detection, stock back-testing
  • Internet of Things (IoT): device tracking for manufacturing, vehicles, fixed and mobile devices
  • Healthcare: real-time patient monitoring, medical device tracking and alerting
  • Logistics: real-time inventory reconciliation, manufacturing flow optimization

A Unified Architecture for Stateful Stream Processing

By integrating a fast, scalable stream-processing engine with an in-memory data grid, ScaleOut Software has created a unified software platform for the next-generation of stream processing. Unlike mainstream platforms such as Apache Flink, Spark, and Storm, ScaleOut StreamServer enables applications to imple­ment object-oriented models of data sources. It can host large populations of data objects in memory on a cluster of commodity servers and dispatch incoming streaming events to these objects for analysis. Applications now can process incoming data streams in a rich context of evolving state, enabling the use of sophisti­cated algorithms while delivering blazingly fast event handling.

ScaleOut StreamServer’s innovative architecture delivers both breakthrough capabilities and peak performance for stateful stream processing. It processes incoming data streams within an in-memory data grid — where the data lives — ensuring minimum latency and peak throughput. Other platforms need to pull state information from remote data stores, such as database servers and distributed caches; this creates delays and network bottlenecks.

Instead, ScaleOut StreamServer delivers streamed events directly to their associated state data, enabling immediate, fully contextual processing. Its transparently scalable platform minimizes the latency required for event tracking and analysis, ensuring timely feedback and/or alerts for the largest workloads.

Integrated Streaming & Batch

ScaleOut StreamServer’s integration of an in-memory data grid and compute engine enables it to simultaneously perform both stream processing and data-parallel analysis on grid-based data. This means that while digital twin objects are processing incoming events, MapReduce (and other data-parallel techniques) can analyze and report aggregate patterns and trends.

Fast, Scalable, and Highly Available

ScaleOut StreamServer employs a unified, fully distributed architecture that transparently scales across commodity servers or cloud instances to increase throughput as needed. This enables the platform to handle large workloads and ensure fast event processing. The grid’s integrated high availability keeps mission-critical data safe at all times.

Unique Advantages for Streaming Data

Traditional CEP and stream processing platforms, such as Apache Flink and Spark Streaming, focus on analyzing incoming data streams without regard to the context in which the data was created. The next generation of stream processing tracks the dynamic state of data sources as “digital twins,” offering a basis for much deeper introspection and more effective alerting. ScaleOut StreamServer’s unique architecture, which executes streaming operations within an in-memory data grid, creates a breakthrough that enables stateful stream processing with digital twin models.

Rich Feature Set

A Powerful Platform for Stateful Stream Processing

ScaleOut StreamServer unleashes the power of stateful stream processing. Its seamless integration of a scalable stream processing engine and in-memory data grid (IMDG) creates a powerful, unified platform for building digital twin models and performing deep introspection on streaming data — with blazing perfor­mance and built-in high availability. These capabilities are delivered as an intuitive, easy to use SDK that makes applica­tion development in C# and Java simple and straightforward. Automatic code shipping to the in-memory data grid simplifies application deployment and helps ensure fast startup times.

Key Features and Capabilities

  • Integrated IMDG and stream-processing engine to enable digital twin models while avoiding unnecessary data motion
  • Automatic code shipping to grid servers to simplify application deployment
  • Support for Reactive Extensions APIs for fast, straightforward event processing using familiar APIs
  • Integration with Kafka connectors and producers to enable seamless connectivity to Kafka messaging pipelines
  • Transparently scalable Kafka  connections that maximize messaging throughput as the workload grows
  • Comprehensive time windowing libraries that make it easy to add time windowing to digital twin models
  • Automatic event routing to associated grid objects that scales throughput as grid servers are added
  • Data-parallel APIs for MapReduce and other operators that integrate batch and stream processing on the same, grid-based data set
  • Object-oriented application design in both Java and C# to simplify development and ensure a clean separation between application logic and grid orchestration.

The Power of Object-Oriented Storage for Live Data

A core requirement for stateful stream processing is to track the state of data sources based on incoming streaming data. ScaleOut StateServer addresses this need with its scalable, highly available, in-memory data grid. The grid’s power in enabling the construction of digital twin models derives from its object-oriented view of data, which allows millions of entities to be tracked as individual objects, each maintaining values for a set of class-defined properties. Applications track and correlate changes to these entities by updating these objects as events flow into the grid.

For example, imagine a system tracking millions of cable TV viewers as they select shows and change channels. By using ScaleOut StreamServer’s IMDG, viewers can be represented as a huge collection of in-memory objects which are individually updated as channel-switch events flow into the grid. Each stored object tracks the behavior of a single viewer, correlating a sequence of events and enriching this data with programming information and viewer preferences. ScaleOut StreamServer also uses a data-parallel compute engine to analyze the population of viewers in parallel and immediately detect important patterns and trends.

Scalable Kafka Connections and Reactive Extensions

ScaleOut StreamServer was designed to seamlessly integrate into existing Kafka streaming data pipelines as both a consumer and producer of streaming data. It takes full advantage of the in-memory data grid’s architecture to automatically scale the number of Kafka connections for large workloads and avoid bottlenecks.

Application developers can use familiar APIs from the popular Reactive Extensions (RX) library to implement extremely fast, lightweight event processing in both C# and Java. These APIs have been integrated with Kafka to allow posting of incoming Kafka messages to RX observables associated with grid objects for stateful stream processing. Likewise, RX observables can be associated with Kafka producers to quickly send outgoing messages.

Designed for Operational Systems

Tracking and correlating live events requires dispatching a continuous stream of events to individual objects with very low latency. This allows the system to maintain a model of the live system, analyze it, and generate immediate results. ScaleOut StreamServer’s integrated in-memory data grid with its flexible storage models was specifically designed to provide the very low access latency required for operational intelligence.

Unlike business intelligence, which uses offline batch-processing, stream processing for operational intelligence requires continuous availability so that analysis results are always available to provide feedback to a live system. ScaleOut StreamServer was designed from the ground up to provide high availability in both its data storage and compute engine. It makes use of patented and patent-pending techniques to ensure that in-memory data is always available and that processing continuess even if a server or network outage occurs.

Industry-Leading Ease of Use

Fast Application Development: No Special Knowledge Required

By integrating stream processing within an in-memory data grid, ScaleOut StreamServer offers capabilities not found in other platforms and delivers on the promise of stateful stream processing while maximizing ease of use. Its familiar, object-oriented data storage and computing model in C# and Java supports advanced analysis algorithms and leverages everything you already know about object-oriented programming. Equally important, it ensures a clean separation between application-specific code and the platform’s orchestration of event processing. The net result is that stateful streaming applications  are straightforward to write and run without the need for specialized knowledge of complex platform semantics designed for stateless stream processing.

Let’s take a closer look. ScaleOut StreamServer organizes in-memory object storage as straightforward object collections in which objects are individually accessible using simple create/read/update/delete APIs. This means that they can track and correlate incoming events from a live system using a straightforward object model. Likewise, collections of objects can be queried using their class properties and analyzed in parallel for batch processing just by defining and invoking class methods. All aspects of application design take full advantage of well understood object-oriented concepts while leveraging more than three decades of experience in simplifying parallel supercomputing.

Automatic Deployment

ScaleOut StreamServer takes ease of use a step further by automating all deployment steps. Using a unique software concept called an “invocation grid,” it lets the application developer pre-stage the execution environment by shipping all required executable programs and libraries to grid servers. This eliminates the need to manually deploy application code and libraries on each server in the cluster, and it ensures that all servers are properly configured. As a further benefit, invocation grids accelerate startup times by avoiding the overhead of shipping code for each parallel method invocation.

ScaleOut Management Pack™ Included!

To further simplify application development, ScaleOut StreamServer comes bundled with ScaleOut Management Pack which includes comprehensive tools for observing, managing, and archiving grid-based data. This means that developers can directly track the state of the grid and easily verify that their applications are running as intended. From development to deployment to testing, ScaleOut StreamServer makes it easy.

Try ScaleOut for free

Use the power of in-memory computing in minutes on Windows or Linux.

Try for Free

Not ready to download?