Introduction to Apama
Apama Overview
What is Apama?
Understanding the different user viewpoints
About Apama license files
Software AG Knowledge Center
Apama Architecture
Distinguishing architectural features
How Apama integrates with external data sources
Descriptions of Apama components
Description of the Apama correlator
Description of event processing languages
Introduction to Apama EPL
Introduction to Apama in-process API for Java (JMon)
Description of Software AG Designer
Description of Query Designer
Description of Event Modeler
Description of Dashboard Builder and Dashboard Viewer
Description of client development kits
Description of Management and Monitoring Console
Description of Apama’s Data Player
How the correlator works
Apama Concepts
Event-driven programming
Complex event processing
Understanding monitors and listeners
Understanding queries
Architectural comparison of queries and monitors
Understanding scenarios and blocks
Understanding dashboards
Getting Ready to Develop Apama Applications
Becoming familiar with Apama
Introduction to Software AG Designer
Steps for developing Apama applications
Overview of starting, testing and debugging applications
Apama Glossary
action
activation
adapter
aggregate function
batch
block
bundle
.cdp
CEP
channel
context
correlator
correlator deployment package
correlator-integrated messaging for JMS
.csv
current events
custom blocks
dashboard
Dashboard Builder
dashboard data server
dashboard display server
Dashboard Viewer
Data Player
data view
EDA
EPL
event
event collection
event listener
Event Modeler
event pattern
event template
.evt
exception
IAF
Integration Adapter Framework (IAF)
JMon
latest event
listener
lot
Management and Monitoring
match set
MemoryStore
.mon
monitor
MonitorScript
parameterization
parameters
partition
partitioning
plug-in
.qry
query
query aggregate
Query Designer
query input definition
query instance
query key
range
.rtv
scenario
.sdf
sentinel agent
simulation
SmartBlock
Software AG Designer
stack trace element
standard blocks
stream
stream listener
stream network
stream source template
stream query
Web Services Client adapter
window
within clause
without clause
Using Apama with Software AG Designer
Overview of Developing Apama Applications
Starting Software AG Designer
Demos and tutorials
The Apama interface
The Apama Workbench perspective
Workbench Project view
The Apama Developer perspective
Project Explorer view
The Apama Runtime perspective
About Apama projects
Managing project hierarchies
Editors
Outline view
Scenario Browser view
Engine Receive view
Engine Status view
Engine Information view
Console view
Problems view
Data Player Control view
Building Apama projects
Launching Apama projects
Specifying the location of the license file
Working with Projects
Creating Apama projects
Adding resources to Apama projects
Creating new monitor files for EPL applications
Creating new query files
Creating new event definition files for EPL applications
Creating event definitions by adding EPL code
Creating event definitions from XML files
Creating event definitions from XSD files
Creating new files for JMon applications
Adding a new JMon application
Adding a JMon monitor
Adding a JMon event
Adding an EPL Plug-in written in Java
Creating new scenarios
Creating new blocks
Creating a block with the block editor
Creating a block from an EPL event definition
Adding EPL code to a block
Creating new scenario functions
Creating new dashboards
Creating dashboards with the Dashboard Generation wizard
Creating dashboards with the Dashboard Builder
Creating new dashboard-deployment configurations
Creating new event files
Adding resources to EPL projects
Adding resources to JMon projects
Adding JMon applications
Adding JMon classes
Adding non-JMon Java files
Adding bundles to projects
Bundle instances
Adding adapters to projects
Adding Universal Messaging configuration to projects
Editing Apama files
Obtaining content assistance
Using auto-completion
Displaying information for events and actions
Specifying comments
Using auto-Indent
Using auto-bracketing
Using tabs
Defining shorthand (templates) for frequently used EPL code
Sharing templates among Software AG Designer installations
Specifying colors to distinguish EPL elements
Shortcuts when editing Apama files
Navigating in Apama files
Using the Outline view to navigate
Using the Quick Outline to navigate
Jumping to an event or action definition or variable declaration
Searching in EPL files
Building Apama projects
Build automatically when a resource changes
Build all Apama projects
Build one Apama project
Build a working set
Clean and rebuild projects
Configuring the project build path
Project source files
Specifying projects
Specifying external dependencies
Specifying dependencies for a single-user project
Specifying dependencies for a multi-user project
Defining MonitorScript Build Path variables
Importing projects
Importing adapter configurations
Setting up the environment before importing projects
Exporting project information
Exporting a project initialization file list
Exporting to a deployment script
Exporting scenarios
Exporting Correlator Deployment Packages
Exporting adapter configurations
Exporting ApamaDoc
Deleting projects and resources
Deleting resources
Deleting projects
Adding the Apama nature to a project
Viewing all EPL objects in all projects
Internationalizing Apama applications
Checking the error log
Using Software AG Designer to configure adapters that use UM
Using Query Designer
Use cases for queries
Adding query files to projects
Steps for using Software AG Designer to implement queries
Overview of creating a query in the Design tab
Creating queries in Query Designer
Configuring queries to import definitions
Adding query inputs
Adding query patterns
Adding query parameters
Adding query conditions
Adding query condition filters (where)
Adding query time constraints (within)
Adding query exclusions (without)
Adding query aggregates
Adding query aggregate calculations
Adding query aggregate filters
Adding query actions
Adding query send event actions
Adding query custom EPL actions
Specifying a time period in Query Designer
Editing source code in Query Designer
Errors in query definitions
Defining query preferences
Configuring query projects
Exporting query deployment scripts
Launching Projects
Running Apama projects
Default launch configuration
Workbench perspective
Developer perspective
Defining custom launch configurations
Adding a correlator
Correlator arguments
Persistence options
Injections
Event Files
Connecting correlators
Adding an external process
Testing a subset of your apama application
Monitoring apama applications
Console view
Using the Engine Information view
Using the Engine Receive view
Engine Receive Viewer preferences
Using the Engine Status view
Using the Scenario Browser view
Displaying the Scenario Browser
Browsing scenarios and query definitions
Creating a new instance of a scenario or a parameterized query
Viewing the instances of a scenario or a query
Editing an instance of a scenario or a parameterized query
Deleting an instance of a scenario or a parameterized query
Deleting all instances of a scenario or a parameterized query
Dashboards
Debugging EPL Applications
Adding breakpoints
Launching a debug session
Creating a debug configuration
Debugging a remote application
Debug view
Breakpoints view
Variables view
Command-line debugger
Debugging JMon Applications
Preparing the correlator for remote debugging
Creating a debug run configuration
Debug perspective
Using the Debug view
Working with breakpoints
Viewing stack frame variables
Example debug session
Debug example of preparing code and JAR file
Debug example of starting correlator and injecting application
Example of debugging in Software AG Designer
Additional resources for Java debugging
Profiling EPL Applications
Launching profiling sessions
Launching a default profiling session
Launching a custom profiling session
Creating a custom profile launch configuration
Launching a remote profiling session
Creating a remote profiler launch configuration
The Apama Profiler perspective
Profiling Monitor view
Execution Statistics view
The Execution Statistics tab
Comparison of Execution Statistics tab
Viewing EPL code
Using filters
Creating a Filter
Managing Filters
Taking snapshots
Using snapshots
Choosing profiling information columns
Updating profile data
Displaying Apama perspective preferences
Using the Data Player
Introduction to the Data Player
Using the Data Player
Adding the ADBC adapter
Configuring the ADBC adapter
Launching the project
Specifying Data Player playback queries
Data Player Control view
Playback settings
Playback controls
Playback status
Creating Data Player query templates
Command-line Data Player interface
Developing Apama Applications
Developing Apama Applications in EPL
Getting Started with Apama EPL
Introduction to Apama Event Processing Language
How EPL applications compare to applications in other languages
About dynamic compilation in the correlator
About the Apama development environment in Software AG Designer
Terminology
Defining event types
Allowable event field types
Format for defining event types
Example event type definition
Working with events
Methods on events
Making event type definitions available to monitors and queries
Channels and input events
Defining Monitors
About monitor contents
Loading monitors into the correlator
Terminating monitors
Unloading monitors from the correlator
Example of a simple monitor
Spawning monitor instances
How spawning works
Sample code for spawning
Terminating monitor instances
About executing ondie() actions
Specifying parameters when spawning
Communication among monitor instances
Organizing behavior into monitors
Event processing order for monitors
Allocating events in monitors
Sending events to other monitors
Defining your application’s message exchange protocol
Using events to control processing
About service monitors
Adding predefined annotations
Subscribing to channels
About the default channel
About wildcard channels
Adding service monitor bundles to your project
Utilities for operating on monitors
Defining Queries
Introduction to queries
Example of a query
Use cases for queries
Delayed and out of order events
Architectural comparison of queries and monitors
Query terminology
Overview of query processing
Overview of query application components
Format of query definitions
Partitioning queries
Defining query keys
Query partition example with one input
Query partition example with multiple inputs
About keys that have more than one field
Defining query input
Format of input definitions
Behavior when there is more than one input
Specifying event duration in windows
Specifying maximum number of events in windows
Specifying event duration and maximum number of events
Using source timestamps of events
Using heartbeat events with source timestamps
Out of order events
Matching only the latest event for a given field
Finding and acting on event patterns
Defining event patterns
Query followed-by operator
Query and operator
Query wait operator
Query conditions
Query condition ranges
Special behavior of the and operator
Aggregating event field values
Event matching policy
Acting on pattern matches
Defining actions in queries
Implementing parameterized queries
Format for defining query parameters
Parameterized queries as templates
Using the Scenario Service to manage parameterized queries
Referring to parameters in queries
Scaling and performance of parameterized queries
Restrictions in queries
Best practices for defining queries
Testing query execution
Communication between monitors and queries
Defining Event Listeners
About event expressions and event templates
Specifying the on statement
Using a stream source template to find events of interest
Defining event expressions with one event template
Listening for one event
Listening for all events of a particular type
Listening for events with particular content
Using positional syntax to listen for events with particular content
Using name/value syntax to listen for events with particular content
Listening for events of different types
Terminating and changing event listeners
Specifying multiple event listeners
Listening for events that do not match
Specifying completion event listeners
Example using unmatched and completed
Improving performance by ignoring some fields in matching events
Defining event listeners for patterns of events
Specifying and/or/not logic in event listeners
Specifying the 'or' operator in event expressions
Specifying the 'and' operator in event expressions
Example event expressions using 'and/or' logic in event listeners
Specifying the 'not' operator in event expressions
Specifying 'and not' logic to terminate event listeners
Pausing event listeners
Choosing which action to execute
Specifying 'and not' logic to detect when events are missing
How the correlator executes event listeners
How the correlator evaluates event expressions
Avoiding event listeners that trigger upon instantiation
When the correlator terminates event listeners
How the correlator evaluates event listeners for a series of events
Evaluating event listeners for all A-events followed by B-events
Evaluating event listeners for an A-event followed by all B-events
Evaluating event listeners for all A-events followed by all B-events
Defining event listeners with temporal constraints
Listening for event patterns within a set time
Waiting within an event listener
Triggering event listeners at specific times
Using variables to specify times
Understanding time in the correlator
Correlator timestamps and real time
Event arrival time
About timers and their trigger times
Disabling the correlator’s internal clock
Externally generating events that keep time (&TIME events)
About repeating timers and &TIME events
Setting the time in the correlator (&SETTIME event)
Out of band connection notifications
Out of band notification events
Enabling out of band notifications
Working with Streams and Stream Queries
Introduction to streams and stream networks
Defining streams
Creating streams from event templates
Terminating streams
Using output from streams
Listener variables and streams
Coassigning to sequences in stream listeners
Defining stream queries
Linking stream queries together
Simple example of a stream network
Stream query definition syntax
Stream query processing flow
Specifying input streams in from clauses
Adding window definitions to from and join clauses
Window definition syntax
Defining time-based windows
Defining size-based windows
Combining time-based and size-based windows
Defining batched windows
Partitioning streams
Partitions and aggregate functions
Using multiple partition by expressions
Partitioning time-based windows
Defining content-dependent windows
Joining two streams
Defining cross-joins with two from clauses
Defining equi-joins with the join clause
Filtering items before projection
Generating query results
Aggregating items in projections
Filtering items in projections
IEEE special values in stream query expressions
Defining custom aggregate functions
Example of defining a custom aggregate function
Defining actions in custom aggregate functions
Overloading in custom aggregate functions
Distinguishing duplicate values in custom aggregate functions
Working with lots that contain multiple items
Stream queries that generate lots
Behavior of stream queries with lots
Size-based windows and lots
Join operations and lots
Grouped projections and lots
Stream network lifetime
Disconnection vs termination
Rules for termination of stream networks
Using dynamic expressions in stream queries
Behavior of static and dynamic expressions in stream queries
When to avoid dynamic expressions in stream queries
Ordering and side effects in stream queries
Understanding when the correlator evaluates particular expressions
Using dynamic expressions in windows
Using dynamic expressions in equi-joins
Using dynamic expressions in where predicates
Using dynamic expressions in projections
Examples of using dynamic expressions in stream queries
Example of altering query window size or period
Example of altering a threshold
Example of looking up values in a dictionary
Example of actions and methods in dynamic expressions
Troubleshooting and stream query coding guidelines
Prefer on statements to from statements
Know when to spawn and when to partition
Filter early to minimize resource usage
Avoid duplication of stream source template expressions
Avoid using large windows where possible
In some cases prefer retain all to a timed window
Prefer equi-joins to cross-joins
Be aware that time-based windows can empty
Be aware that fixed-size windows can overflow
Beware of accidental stream leaks
Defining What Happens When Matching Events Are Found
Using variables
Using global variables
Using local variables
Using variables in listener actions
Specifying named constant values
Defining actions
Format for defining actions
Invoking an action from another action
Specifying actions in event definitions
Using action type variables
Getting the current time
Generating events
Generating events with the route command
Generating events with the send command
Sending events to com.apama.Channel objects
Generating events with the enqueue command
Enqueuing to contexts
Generating events to emit to outside receivers
Assigning values
Defining conditional logic
Defining loops
Catching exceptions
Logging and printing
Specifying log statements
Log levels determine results of log statements
Where do log entries go?
Examples of using log statements
Strings in print and log statements
Sample financial application
Implementing Parallel Processing
Introduction to contexts
What is inside/outside a context?
About context properties
Context lifecycle
Comparison of a correlator and a context
Creating contexts
Calling context methods
How many contexts can you create?
Using channels to communicate between contexts
Obtaining context references
Spawning to contexts
Channels and contexts
Sending an event to a channel
Sending an event to a particular context
Sending an event to a sequence of contexts
Common use cases for contexts
Samples for implementing contexts
Simple sample implementation of contexts
Running samples of common concurrency problems
About the samples of concurrency problems
About the race sample
About the deadlock sample
About the compareswap sample
Contexts and correlator determinism
How contexts affect other parts of your Apama application
About input logs and parallel processing
Deadlock avoidance when parallel processing
Clock ticks when parallel processing
Using correlator plug-ins in parallel processing applications
Using Correlator Persistence
Description of state that can be persistent
When persistence is useful
When non-persistent monitors are useful
How the correlator persists state
Enabling correlator persistence
How the correlator recovers state
Recovery order
Defining recovery actions
Simplest recovery use case
Designing applications for persistence-enabled correlators
Upgrading monitors in a persistence-enabled correlator
Sample code for persistence applications
Sample code for discarding stale state during recovery
Sample code for recovery behavior based on downtime duration
Sample code that recovers subscription to non-persistent monitor
Requesting snapshots
Developing persistence applications
Using correlator plug-ins when persistence is enabled
Using the MemoryStore when persistence is enabled
Comparison of correlator persistence with other persistence mechanisms
Restrictions on correlator persistence
Common EPL Patterns in Monitors
Contrasting using a dictionary with spawning
Translation using a dictionary
Translation using spawning
Factory pattern
Canonical factory pattern
Alternate factory pattern
Using quit() to terminate event listeners
Combining the dictionary and factory patterns
Testing uniqueness
Reference counting
Inline request-response pattern
Routing events for request-response behavior
Canonical form for synchronous requests
Writing echo monitors for debugging
Using Correlator Plug-ins in EPL
Overhead of using plug-ins
When to use plug-ins
When not to use plug-ins
Using the TimeFormat Event Library
TimeFormat format functions
TimeFormat parse functions
Format specification for the TimeFormat functions
Using the MemoryStore
Introduction to using the MemoryStore
Overview of MemoryStore events
Adding the MemoryStore bundle to your project
Steps for using the MemoryStore
Preparing and opening stores
Description of row structures
Preparing and opening tables
Using transactions to manipulate rows
Determining which commit action to call
Creating and removing rows
Iterating over the rows in a table
Requesting persistence
Exposing in-memory or persistent data to dashboards
Restrictions affecting MemoryStore disk files
Using the distributed MemoryStore
Overview of the distributed MemoryStore
Distributed store transactional and data safety guarantees
Using a distributed store
Configuring a distributed store
Adding distributed MemoryStore support to a project
Adding a distributed store
Configuring a distributed store
Launching a project that uses a distributed store
Interacting with a distributed store
Configuration files for distributed stores
BigMemory Max driver specific details
Changing bean property values when deploying projects
Creating a distributed MemoryStore driver
Using the Management interface
Using MATLAB® products in an application
MatlabManager actions
MATLAB examples
Interfacing with user-defined correlator plug-ins
About the chunk type
Making Application Data Available to Clients
Adding the DataView service bundle to your project
Creating DataView definitions
DataViewAddDefinition
DataViewDefinition
DataViewException
Example
Deleting DataView definitions
DataViewDeleteDefinition
DataViewDefinitionDeleted
Creating DataView items
DataViewAddItem
DataViewAddOrUpdateItem
DataViewItem
DataViewItemException
Example
Deleting DataView Items
DataViewDeleteItem
DataViewItemDeleted
Example
DataViewDeleteAllItems
DataViewAllItemsDeleted
Updating DataView Items
DataViewUpdateItem
Example
DataViewUpdateItemDelta
Example
Looking Up Field Positions
DataViewGetFieldLookup
DataViewFieldLookup
Using multiple correlators
Testing and Tuning EPL monitors
Optimizing EPL programs
Best practices for writing EPL
Wildcard fields that are not relevant
Avoiding unnecessary allocations
Implementing states
Structure of a basic test framework
Using event files
Handling runtime errors
What happens
Using ondie() to diagnose runtime errors
Using logging to diagnose errors
Standard diagnostic log output
Capturing test output
Avoiding listeners and monitor instances that never terminate
Handling slow or blocked receivers
Diagnosing infinite loops in the correlator
Tuning contexts
Parallel processing for instances of an event type
Parallel processing for long-running calculations
Generating Documentation for Your EPL Code
Code constructs that are documented
Steps for using ApamaDoc
Inserting ApamaDoc comments
Inserting ApamaDoc tags
Inserting ApamaDoc references
Generating ApamaDoc in headless mode
Developing Apama Applications in Event Modeler
Overview of Using Event Modeler
Event Modeler layout
About event flow states
How rules define scenario behavior
Description of rule conditions
Description of rule actions
Description of functions in rules
About rule evaluation
Basic view of rule processing
Expanded view of rule processing
Scenario monitoring stage
Summary of adding rules when a variable value changes
About scenario variables
Variable types
Auto-typing of variables
Variable properties
Variable constraints
User input and output
About blocks
Linking variables, block parameters, and block output fields
Using Event Modeler
Adding scenarios to projects
Creating the GlobalRuleExample project
Adding GlobalRuleExample.sdf to the GlobalRuleExample project
Adding a new scenario to the GlobalRuleExample project
Opening and viewing multiple scenarios
Selecting from the Scenario menu
The Event Modeler toolbar
Interacting with the tabs and panels
Working in the Event Flow panel
Interacting with states
Selecting a state
Resizing a state
Moving a state
Multiple selection
Adding a state
The finished status
Deleting a state
Labeling a state
Using cut/copy/paste with states
Interacting with transitions
Adding a transition
Selecting a transition
Changing end-points
Changing the shape of a transition
Labeling a transition
Deleting a transition
Using cut/copy/paste with transitions
Displaying global rule transitions
Working in the Rules panel
Adding a rule
About global rules
Selecting rules and rule elements
Re-ordering rules
Deleting a rule
Labeling a rule
Changing a rule’s description
Minimizing and maximizing a rule
Cutting, copying, and pasting rules
Activating and deactivating rules
Specifying conditions
Interactive editing
Language elements
Selecting and replacing elements
Cascading alternative menus
Using functions in rules
Adding a condition to a rule
Specifying variable changes in conditions
Local rules and variable changes
Global rules and variable changes
Specifying actions
Adding action statements
Deleting action statements
Interactive editing
Using the keyboard to edit rules
Using the Variables tab
Adding a variable
Renaming a variable
Selecting a variable
Determining which states use a particular variable
Moving a variable
Deleting a variable
Changing a variable’s properties
Setting a variable’s value
Variable input and output
Linking a variable to a block output field
Conversion rules for variable types
Using the Catalogs tab
Adding a block template catalog
Selecting and inspecting a block template
Adding a block instance to the scenario
Using the Functions tab
Adding a function catalog
Selecting and inspecting a function
Using the Blocks tab
Interacting with a block instance
Selecting a parameter
Viewing a parameter’s properties
Setting a parameter’s initial value
Linking a parameter with a variable or output field
Switching blocks
Using the Block Wiring tab
Wiring block input feeds
Selecting, resizing, and moving block instances
Wiring two blocks together
Connecting feeds and specifying feed mapping
Wiring a scenario variable to a block
Mapping type conversions
Editing block wiring
Deleting a wiring
Deleting a block instance
Using older versions of blocks
Troubleshooting invalid scenarios
Setting preferences
Exporting scenarios as EPL
Exporting scenarios as block templates
Event Modeler command line options
Using Standard Blocks
A block’s lifecycle
General analytic blocks
Change Notifier v2.0
Correlation Calculator v2.0
Data Distribution Calculator v2.0
Median and Mode Calculator v1.0
Moving Average v1.0
Spread Calculator v3.0
Statistics Calculator v1.0
Velocity Calculator v2.0
The Timer blocks
Schedule v3.0
Wait v3.0
The Utility blocks
Dictionary v2.0
File Reader v2.0
File Writer v2.0
History Logger v2.0
Input Merger v2.0
List v2.0
Scenario Terminator v2.0
Status v2.0
Variable Mapper v2.0
Database functionality—storage and retrieval
ADBC Storage v1.0
ADBC Retrieval v1.0
Blocks for working with scenario blocks
Change Observer v2.0
Filtered Summary v2.0
Using Functions in Event Modeler
Reference information for provided functions
Date and time functions
Extended math functions on float types
IO functions
System value functions
Miscellaneous functions
Extended math functions on float types
About defining your own functions
Sample ABS function definition file
Sample function definition file with imports element
About function names
Creating Blocks
About blocks
Introduction to block definition files
Description of block interface elements
How scenarios communicate with their blocks
Defining new blocks in Software AG Designer
Specifying the block metadata
Specifying the block interface
Creating parallel-aware blocks
Adding EPL code to the block definition
Considerations for adding EPL code to the block definition
Details about EPL code that you can add
Timeliness of acknowledgements
An example block
Description of the Correlation Calculator block interface
Description of the Correlation Calculator block EPL
Working with Blocks Created from Scenarios
Terminology for using scenario blocks
Benefits of scenario blocks
Steps for using scenario blocks
Background for using scenario blocks
Saving scenarios as block templates
Incrementing scenario block version numbers
Adding a scenario block to a main scenario
Examining a scenario block’s source scenario
Descriptions of scenario block parameters
Descriptions of scenario block operations
Descriptions of scenario block feeds
Setting parameters before creating sub-scenarios
Creating sub-scenarios
Deleting sub-scenarios
Unconditionally deleting a sub-scenario
Deleting all sub-scenarios
Modifying sub-scenario input variable values
Iterating through sub-scenarios
Obtaining variable values from sub-scenarios
Linking sub-scenarios with other blocks
Inheriting sub-scenarios
Description of inheritExternalInstances values
Notes for setting the inheritExternalInstances parameter
Example of inheriting sub-scenarios
Observing changes in sub-scenarios
Performing simple calculations across sub-scenarios
File Definition Formats
Function definition file format
Defining metadata in function definition files
Defining the version element
Defining the description element
Defining the imports element
Defining the parameters element
Defining EPL code in function definition files
Block definition file format
Block definition file DTD
Block definition file encodings
XML elements that define a block
Developing Apama Applications in Java
Overview of Apama JMon Applications
Introducing JMon API concepts
About event types
Simple example of an event type
Extended example of a JMon event type
Comparing JMon and EPL event type parameters
About event parameters that are complex types
Non-null values for non-primitive event field types
About monitors
About event listeners and match listeners
Example of a MatchListener
Defining multiple listeners
Removing listeners
Description of the flow of execution in JMon applications
Parallel processing in JMon applications
Overview of contexts in JMon applications
Using contexts in JMon applications
Using the Context class default constructor
Descriptions of methods on the Context class
Identifying external events
Optimizing event types
Wildcarding parameters in event types
Logging in JMon applications
Using EPL keywords as identifiers in JMon applications
Defining Event Expressions
About event templates
Specifying positional syntax
Specifying completed event templates
Specifying parameter constraints in event templates
Obtaining matching events
Emitting, routing, and enqueuing events
Specifying temporal sequencing
Chaining listeners
Using temporal operators
Defining advanced event expressions
Specifying other temporal operators
Specifying a perpetual listener for repeated matching
Deactivating a listener
Temporal contexts
Specifying the timer operators
Looking for event sequences within a set time
Waiting within a listener
Working with absolute time
Optimizing event expressions
Validation of event expressions
Concept of Time in the Correlator
Correlator timestamps and real time
Event arrival time
Getting the current time
About timers and their trigger times
Developing and Deploying JMon Applications
Steps for developing JMon applications in Software AG Designer
Java prerequisites for using Apama's JMon API
Steps for developing JMon applications manually
Deploying JMon applications
Removing JMon applications from the correlator
Creating deployment descriptor files
Format for deployment descriptor files
Specifying classpath in deployment descriptor files
Defining event types in deployment descriptor files
Defining monitor classes in deployment descriptor files
Inserting annotations for deployment descriptor files
Sample source files with annotations
Generating deployment descriptor files from annotations
Package names and namespaces in JMon applications
Sample JMon applications
Developing Correlator Plug-ins
Introduction to Correlator Plug-ins
Providing an EPL event wrapper for a plug-in
Writing a Plug-in in C or C++
A simple plug-in in C++
Calling the test function from EPL
A simple C plug-in
Parameter-less plug-in functions
Advanced Plug-in Functionality in C++ and C
Introducing complex_plugin
The chunk type
Working with chunk in C++
Working with chunk in C
Working with sequences
The complete example
Using complex_plugin from the event correlator
Asynchronous plug-ins
Writing correlator plug-ins for parallel processing applications
Working with blocking behavior in C++ plug-ins
Working with channels in C++ plug-ins
The EPL Plug-in APIs for C and C++
Primary class types
Writing Correlator Plug-ins in Java
Creating a plug-in using Java
Permitted signatures for methods
Using Java plug-ins
Sample plug-ins in Java
A simple plug-in in Java
A more complex plug-in in Java
A plug-in in Java that sends events
A plug-in in Java that subscribes to receive events
EPL Reference
Introduction
Hello World example
Types
Primitive and string types
boolean
decimal
float
integer
string
Reference types
action
Channel
chunk
context
dictionary
event
Exception
listener
location
sequence
StackTraceElement
stream
monitor pseudo-type
Type properties summary
Timestamps, dates, and times
Type methods and instance methods
Type conversion
Comparable types
Cloneable types
Potentially cyclic types
Which types are potentially cyclic?
String form of potentially cyclic types
Support for IEEE 754 special values
Events and Event Listeners
Event definitions
Event fields
Event actions
Event field and action scope
Event templates
By-position qualifiers
By-name qualifiers
Range expressions
Field operators
Event listener definitions
Event lifecycle
Event listener lifecycle
Event processing order for monitors
Event processing order for queries
Event expressions
Event primaries
Timers
The not operator
The all operator
The and, xor, and or logical event operators
The followed-by event operator
Event expression operator precedence
Event channels
Monitors
Monitor lifecycle
Monitor files
Packages
The using declaration
Monitor declarations
The import declaration
Monitor actions
Simple actions
Actions with parameters
Contexts
Plug-ins
Garbage collection
Queries
Query lifetime
Query definition
Parameters section
Inputs section
Query input definition
Find statement
Pattern
Where condition
Within condition
Without condition
Between clause
Select clause
Having clause
Reserved words in queries
Aggregate Functions
Built-in aggregate functions
Custom aggregates
Statements
Simple statements
The assignment statement
The emit statement
The enqueue statement
The enqueue . . . to statement
The expression statement
The log statement
The print statement
The route statement
The send . . . to statement
The spawn statement
The spawn action to context statement
Variable declaration statements
Compound statements
The for statement
The from statement
The if statement
The on statement
The while statement
The try-catch statement
Transfer of control statements
The break statement
The continue statement
The die statement
The return statement
Expressions
Introduction to expressions
Primary expressions
Bitwise logical operators
Bitwise intersection (and)
Bitwise union (or)
Bitwise exclusive (xor)
Unary bitwise inverse
Logical operators
Logical intersection (and)
Logical union (or)
Logical exclusive or (xor)
Unary logical inverse (not)
Shift operators
Left shift operator
Right shift operator
Comparison operators
Additive operators
Multiplicative operators
Unary additive operators
Expression operators
Expression operator precedence
Postfix expressions
Action and method calls
The subscript operator [ ]
The new object creation operator
Stream queries
Stream query window definitions
Stream source templates
Variables
Variable declarations
Variable scope
Predefined variable scope
Monitor scope
Action scope
Block scope
Event action scope
Custom aggregate function scope
Provided variables
currentTime
Event timestamps
self
Specifying named constant values
Lexical Elements
Program text
Comments
White space
Line terminators
Symbols
Identifiers
Keywords
List of EPL keywords
List of identifiers reserved for future use
Escaping keywords to use them as identifiers
Operators
Separators
Literals
Boolean literals
Integer literals
Base 10 literals
Base 16 literals
Floating point and decimal literals
String literals
Location literals
Dictionary literals
Sequence literals
Time literals
Names
Annotations
Limits
Obsolete Language Elements
Old style listener calls
Old style spawn statements
EPL Naming Conventions
EPL Keyword Quick Reference
EPL Methods Quick Reference
action methods
boolean methods
Channel methods
chunk methods
context methods
decimal and float methods
dictionary methods
event methods
Exception methods
integer methods
listener methods
location methods
monitor methods
sequence methods
StackTraceElement methods
stream methods
string methods
EPL Streams: A Quick Tour
About the Apama event stream processing model
Example events for stream queries
Processing events using streams
Creating a stream network
Using inline stream source template expressions
Using compound stream queries
Using dynamic values in stream queries
Using stream variables
Using the short-form from statement
Stream lifetime
Using windows in stream queries
Using joins in stream queries
Using partitions and groups in stream queries
Using rstream
Common stream query patterns
Aggregation in stream queries
Throttling in stream queries
Dynamic filters in stream queries
Joining the most recent event on each of two streams
Retaining the most recent item in each partition of a partitioned stream
Joining an event with a previous event
Connecting Apama Applications to External Components
Using Standard Adapters
Using the Apama Database Connector
Overview of using ADBC
Registering your ODBC database DSN on Windows
Adding an ADBC adapter to an Apama project
Configuring the Apama database connector
Configuring an ADBC adapter
Manually editing a configuration file
Configuring ADBC localization
Configuring ADBC Automatic Database Close
Service monitors
ADBC blocks
Codecs
The ADBCHelper Application Programming Interface
ADBCHelper API Overview
Opening databases
Specifying the adapter instance
Checking to see if a database is open
Issuing and stopping SQL queries
Issuing SQL commands
Committing database changes
Performing rollback operations
Handling query results for row data
Handling query results for event data
Handling acknowledgments
Handling errors
Reconnection settings
Closing databases
Getting schema information
Setting context
Logging
Examples
The ADBC Event Application Programming Interface
Discovering data sources
Discovering databases
Opening a database
Closing a database
Storing event data
Storing non-event data
Creating and deleting store events
Handling data storing errors
Committing transactions
Rolling back transactions
Running commands
Executing queries
Executing standard queries
Stopping queries
Preserving column name case
Prepared statements
Using a prepared statement
Stored procedures
Using a stored procedure
Named queries
Using named queries
Creating named queries
The Visual Event Mapper
Using the Visual Event Mapper
Playback
Sample applications
Format of events in .sim files
Using the Apama Web Services Client Adapter
Web Services Client adapter overview
Adding a Web Services Client adapter to an Apama project
Configuring a Web Services Client adapter
Specify the Web Service and operation to use
Specifying Apama events for mapping
Editing Web Services Client adapter configurations
Adding multiple instances of the Web Services Client adapter
Mapping Web Service message parameters
Simple mapping
Convention-based XML mapping
Convention-based Web Service message mapping example
Add Computed Node dialog
Template-based mapping
Combining convention and template mapping
Mapping complex types
Difference between doc literal and RPC literal WSDLs
Using custom EL mapping extensions
JUEL mapping expressions reference for Web Client Services adapter
Specifying a correlation ID field
Specifying transformation types
Specifying an XSLT transformation type
Specifying an XPath transformation type
Using the XPath Helper
Launching the XPath Helper
Setting node properties
Generating XPath expressions
Adding and removing namespaces
Evaluating XPath expressions
Customizing mapping rules
Mapping SOAP body elements
Mapping SOAP header elements
Mapping HTTP header elements
Using EPL to interact with Web Services
Configuring logging for Web Services Client adapter
Web Services Client adapter artifacts
Updating a Web Service operation using the Archive Editor
Using the Apama File Adapter
File Adapter plug-ins
File Adapter service monitor files
Adding the File adapter to an Apama project
Configuring the File adapter
Overview of event protocol for communication with the File adapter
Opening files for reading
Opening files for reading with parallel processing applications
Specifying file names in OpenFileForReading events
Opening comma separated values (CSV) files
Opening fixed width files
Sending the read request
Requesting data from the file
Receiving data
Opening files for writing
Opening files for writing with parallel processing applications
LineWritten event
Monitoring the File adapter
Using Adapter Plug-ins
The Null Codec plug-in
Null codec transport-related properties
The File Transport plug-in
The String Codec plug-in
The Filter Codec plug-in
Filter codec transport-related properties
Specifying filters for the filter codec
Examples of filter specifications
The XML codec plug-in
Supported XML features
Adding XML codec to adapter configuration
Setting up the classpath
About the XML parser
Specifying XML codec properties
Required XML codec properties
XML codec transport-related properties
Message logging properties
Downstream node order suffix properties
Additional downstream properties
Sequence field properties
Upstream properties
Performance properties
Description of event fields that represent normalized XML
Examples of conversions
Sequence field example
XPath examples
The CSV codec plug-in
Multiple configurations and the CSV codec
Decoding CSV data from the sink to send to the correlator
Encoding CSV data from the correlator for the sink
The Fixed Width codec plug-in
Multiple configurations and the Fixed Width codec
Decoding fixed width data from the sink to send to the correlator
Encoding fixed width data from the correlator for the sink
Using Message Services
Using Correlator-Integrated Messaging for JMS
Overview of correlator-integrated messaging for JMS
Samples for using correlator-integrated messaging for JMS
Key concepts for correlator-integrated messaging for JMS
Getting started with simple correlator-integrated messaging for JMS
Adding and configuring connections
Adding JMS receivers
Configuring receiver event mappings
Using conditional expressions
Adding a classpath variable entry
Configuring sender event mappings
Using EPL to send and receive JMS messages
Getting started with reliable correlator-integrated messaging for JMS
Mapping Apama events and JMS messages
Simple mapping for JMS messages
Using expressions in mapping rules
Template-based XML generation
Specifying an XPath transformation for JMS messages
Specifying an XSLT transformation for JMS messages
Convention-based XML mapping
Convention-based JMS message mapping example
Using convention-based XML mapping when receiving/parsing messages
Using convention-based XML mapping when sending/generating messages
Combining convention-based XML mapping with template-based XML generation
Using EDA events in Apama applications
About convention-based EDA mapping
Rules that govern automatic conversion between of EDA events and Apama events
Rules that govern EPL name generation
Creating Apama event type definitions for EDA events
Automatically mapping configurations for EDA events
Manually mapping configurations for EDA events
Handling binary data
Using custom EL mapping extensions
JUEL mapping expressions reference for JMS
Implementing a custom Java mapper
Dynamic senders and receivers
Durable topics
Receiver flow control
Monitoring correlator-integrated messaging for JMS status
Logging correlator-integrated messaging for JMS status
JMS configuration reference
Configuration files
XML configuration file format
¦XML configuration bean reference
Advanced configuration bean properties
Designing and implementing applications for correlator-integrated messaging for JMS
Using correlator persistence with correlator-integrated messaging for JMS
How reliable JMS sending integrates with correlator persistence
How reliable JMS receiving integrates with correlator persistence
Sending and receiving reliably without correlator persistence
Receiving messages with APP_CONTROLLED acknowledgements
Sending messages reliably with application flushing notifications
Using the correlator input log with correlator-integrated messaging for JMS
Reliability considerations when using JMS
Duplicate detection when using JMS
Performance considerations when using JMS
Performance logging when using JMS
Receiver performance when using JMS
Sender performance when using JMS
Configuring Java options and system properties when using JMS
Diagnosing problems when using JMS
JMS failures modes and how to cope with them
Using Universal Messaging in Apama Applications
Overview of using UM in Apama applications
Comparison of Apama channels and UM channels
Choosing when to use UM channels and when to use Apama channels
General steps for using UM in Apama applications
About events transported by UM
Using UM channels instead of engine_connect
Using UM channels instead of configuring adapter connections
Enabling automatic creation of UM channels
Considerations for using UM channels
Setting up UM for use by Apama
Starting correlators that use UM
Configuring adapters to use UM
EPL and UM channels
Defining UM properties for Apama applications
Monitoring Apama application use of UM
Developing Custom Adapters
The Integration Adapter Framework
Overview
Architecture
The transport layer
The codec layer
The Semantic Mapper layer
Contents of the IAF
Using the IAF
The IAF runtime
IAF library paths
IAF command line options
IAF log file status messages
IAF log file rotation
IAF Management – Managing a running adapter I
IAF Client – Managing a running adapter II
IAF Watch – Monitoring running adapter status
The IAF configuration file
Including other files
Transport and codec plug-in configuration
Event mappings configuration
Apama event correlator configuration
Configuring adapters to use UM
Logging configuration (optional)
Java configuration (optional)
IAF samples
C/C++ Transport Plug-in Development
The C/C++ transport plug-in development specification
Transport functions to implement
Defining the transport function table
The transport constructor, destructor and info functions
Other transport definitions
Transport utilities
Communication with the codec layer
Transport Example
Getting started with transport layer plug-in development
C/C++ Codec Plug-in Development
The C/C++ codec Plug-in Development Specification
Codec functions to implement
Codec encoder functions
Codec decoder functions
Defining the codec function tables
The codec function table
The codec encoder function table
The codec decoder function table
Registering the codec function tables
The codec constructor, destructor and info functions
Other codec definitions
Codec utilities
Communication with other layers
Working with normalized events
The AP_NormalisedEvent structure
The AP_NormalisedEventIterator structure
Transport Example
Getting Started with codec layer plug-in development
C/C++ Plug-in Support APIs
Logging from plug-ins in C/C++
Using the latency framework
C/C++ timestamp
C/C++ timestamp set
C/C++ timestamp configuration object
C/C++ latency framework API
Transport Plug-in Development in Java
The Transport Plug-in Development Specification for Java
Java transport functions to implement
Communication with the codec layer
Sending upstream messages received from a codec plug-in to a sink
Sending downstream messages received from a source on to a codec plug-in
Transport exceptions
Logging
Example
Getting started with Java transport layer plug-in development
Java Codec Plug-in Development
The Codec Plug-in Development Specification for Java
Java codec functions to implement
Communication with other layers
Sending upstream messages received from the Semantic Mapper to a transport plug-in
Sending downstream messages received from a transport plug-in to the Semantic Mapper
Java codec exceptions
Semantic Mapper exceptions
Logging
Working with normalized events
The NormalisedEvent class
The NormalisedEventIterator class
Java Codec Example
Getting started with Java codec layer plug-in development
Plug-in Support APIs for Java
Logging from plug-ins in Java
Using the latency framework
Java timestamp
Java timestamp set
Java timestamp configuration object
Java latency framework API
Monitoring Adapter Status
IAFStatusManager
Application interface
Input events
Output events
Returning information from the getStatus method
Connections and other custom properties
Asynchronously notifying IAFStatusManager of connection changes
Mapping AdapterConnectionClosed and AdapterConnectionOpened events
StatusSupport
StatusSupport events
Out of Band Connection Notifications
Mapping example
Ordering of out of band notifications
The Event Payload
Developing Custom Clients
The Client Software Development Kits
Basic operations
The client software development kits
The Client Software Development Kits for C++ and Java
The library classes
Main classes
Data classes
Event correlator interrogation and status
Additional functionality
Exceptions
Logging in C++
Logging in Java
Thread-safety
The complete definitions
The C++ header file
Using the SDKs – C++ and Java Examples
A simple echo server in C++
The full example in C++
The Java example
The C Client Software Development Kit
Using the C SDK
The complete C example
The EngineClient API
The Java EngineClient API
The key elements
Overview of the EngineClientBean
Functionality of the EngineClientBean
Recommended usage
Logging
Inject operations
Delete operations
Inspect operations
Receive operations
Send operations
Watch operations
GenericComponentManagementBean
The .NET Engine Client library
Using the .NET client library
Java and .NET namespace/class mapping
The EventService API
The key elements
The IEventService interface
The IEventServiceChannel interface
The EventServiceFactory class
Examples of use
The ScenarioService API
The key elements
The IScenarioService interface
The ScenarioDefinition interface
The IScenarioInstance interface
The ScenarioServiceFactory class
The ScenarioServiceConfig class
Examples of use
Building and Using Dashboards
Building Dashboard Clients
Introduction to Building Dashboard Clients
Web client requirements
About dashboards
Starting the Dashboard Builder
Starting Builder from the Windows Start menu
Starting Builder from Software AG Designer
Specifying Dashboard Builder options
Starting Builder from the command line
Scenario instance and DataView item ownership
Using the tutorial application
Using Dashboard Builder
Dashboard Builder layout
The menubar
The toolbar
The canvas
The Object Palette
The Object Properties panel
Specifying data sources
Specifying correlators
Specifying XML data sources
Activating data source specifications
Saving data source specifications
Setting the background properties
About resize modes
About resize modes and Display Server deployments
About resize modes and composite objects
Working with objects
Adding objects to a dashboard
Selecting an object
Resizing objects
Moving objects
Copy and pasting objects
Deleting objects
Setting Builder options
Setting Dashboard options
Setting options in the General tab group
Setting options in the General tab
Setting options in the Substitutions tab
Setting options in the Data Server tab
Setting options in the Custom Colors tab
Setting options in the Apama tab group
Setting options in the SQL tab group
Setting options in the XML tab group
Saving options
Command line options
Attaching Dashboards to Correlator Data
Dashboard data tables
Scenario instance table
Scenario trend table
Scenario OHLC table
Correlator status table
Data Server status table
Scenario constraint table
DataView item table
DataView trend table
DataView OHLC table
SQL-based instance table
Setting data options
Scenario instance and DataView item ownership
Creating a data attachment
Using the Attach to Apama dialog
Selecting display variables or fields
Displaying attached data
Filtering data
Attaching to constraint data
About timestamps
Using dashboard variables in attachments
About non-substitution variables
About drilldown and $instanceId
About other predefined substitution variables
Using SQL-based instance tables
Working with multiple Data Servers
Builder with multiple Data Servers
Viewer with multiple Data Servers
Display Server deployments with multiple Data Servers
Applet and WebStart deployments with multiple Data Servers
Using table objects
Creating a scenario summary table
Filtering rows of a scenario summary table
Performing drilldowns on tables
Specifying drill-down column substitutions
Hiding table columns
Using pre-set substitution variables for drill down
Formatting table data
Colorizing table rows and cells
Setting column headers
Using rotated tables
Using pie and bar charts
Creating a summary pie or bar chart
Using series and non-series bar charts
Performing drilldowns on pie and bar charts
Using trend charts
Creating a scenario trend chart
Charting multiple variables
Adding thresholds
Configuring trend-data caching
Rendering trend charts in HTML5
Using stock charts
Using OHLC values
Creating a scenario stock chart
Adding overlays
Recreating the Stock Chart Overlay sample
Generating OHLC values
Localizing dashboard labels
Localizing dashboard messages
Using Dashboard Functions
Using built-in functions
Creating custom functions
Developing a custom-function library
Implementing getFunctionDescriptors
Implementing evaluateFunction
Installing a custom-function library
Sample IFunctionLibrary implementation
Defining Dashboard Commands
Scenario lifecycle
Defining commands
Using dashboard variables in commands
Defining commands for creating a scenario instance
Defining commands for editing a scenario instance
Supporting deletion of a scenario instance
Supporting deletion of all instances of a scenario
Using popup dialogs for commands
Command options
Associating a command with keystrokes
Defining multiple commands
Creating custom commands
Developing a custom-command library
Installing a Custom-Command Library
Sample ICommandLibrary implementation
Apama set substitution command
Reusing Dashboard Components
Using Object Grids
Configuring Object Grids
Recreating the Object Grid sample
Using Composite objects
Creating files to display in composite objects
Configuring Composite objects
Using substitutions with Composite objects
Composite object interactivity
Composite object sample
Recreating the Composite object sample
Using Composite Grids
Configuring Composite Grids
Composite Grid sample
Recreating the Composite Grid sample
Using include files
Include File sample
Recreating the Include File sample
Working with multiple display panels
About the format of the panels-configuration file
Using new tags to configure the panels in a window
Configuring panels with accordion controls
Configuring static tree navigation panels
Configuring tabbed navigation panels
Using tab definition files
Examples of configuration files for multiple panels
Using tree controls in panel displays
Creating tree controls
Configuring tree control icons
Specifying tree control properties
Tree control limitations
Using old tags to configure the panels in a window
Using border panels
Using card panels
Using grid panels
Using tabs panels
Using tree panels
Using the RTViewNavTreePanel tag
Using the RTViewPanel tag
Sending Events to Correlators
Using the Define Apama Command dialog
Command field
Package field
Event field
Channel field
Other dialog fields
Default values
Specifying values for complex types
Updating event definitions in Builder
Example
Send event authorization
Using XML Data
XML data format
Scalar data elements
Tabular data elements
Defining an XML data source
Attaching objects to XML data
Using SQL Data
SQL system requirements and setup
Attaching visualization objects to SQL data
Validation colors
Substitutions
Select table columns
Defining SQL commands
Validation colors
Special values
Specifying application options
SQL tab
Adding a Database
Database repository
Entering database information directory into OPTIONS.ini
Generating encrypted passwords for SQL data sources
Deploying applet and WebStart dashboards
Setting up SQL database connections
Direct JDBC connection
Setting SQL data source options
Dashboard Property Reference for Graphs, Tables and Trends
Introduction to Dashboard Properties
Objects for complex-data visualization
About the Object Properties window
Editing property values
Copying and pasting property values
Graph Objects
Bar graphs
Bar graph: Alert group
Bar graph: Background group
Bar graph: Bar group
Bar graph: Column group
Bar graph: Data group
Bar graph: Data Format group
Bar graph: Data Label group
Bar graph: Historian group
Bar graph: Interaction group
Bar graph: Label group
Bar graph: Layout group
Bar graph: Legend group
Bar graph: Marker group
Bar graph: Object group
Bar graph: Plot Area group
Bar graph: Trace group
Bar graph: X-Axis group
Bar graph: Y-Axis group
Heat map
Heat maps with one index column
Heat maps with multiple index columns
Mapping from possible aggregation results to colors
Drill down displays
Object class name
Heat map property groups
Heat map: Background properties
Heat map: Data group
Heat map: Data format group
Heat map: Data Label group
Heat map: Historian group
Heat map: Interaction group
Heat map: Label group
Heat map: Layout group
Heat map: Node group
Heat map: Object group
Heat map: Quality group
Legend
Legend: Background group
Legend: Data group
Legend: Historian group
Legend: Interaction group
Legend: Label group
Legend: Legend group
Legend: Object group
Pie graph
Pie graph: Background group
Pie graph: Column group
Pie graph: Data group
Pie graph: Data Format group
Pie graph: Data Label group
Pie graph: Historian group
Pie graph: Interaction group
Pie graph: Label group
Pie graph: Legend group
Pie graph: Object group
Pie graph: Wedge group
Radar graph
Radar graph: Alert group
Radar graph: Background group
Radar graph: Column group
Radar graph: Data group
Radar graph: Data Format group
Radar graph: Data Label group
Radar graph: Historian group
Radar graph: Interaction group
Radar graph: Label group
Radar graph: Legend group
Radar graph: Marker group
Radar graph: Object group
Radar graph: Plot Area group
Radar graph: Radial Axis group
Radar graph: Trace group
Radar graph: Value Axis group
XY graph
XY graph: Alert group
XY graph: Background group
XY graph: Column group
XY graph: Data group
XY graph: Data Format group
XY graph: Data Label group
XY graph: Historian group
XY graph: Interaction group
XY graph: Label group
XY graph: Legend group
XY graph: Marker group
XY graph: Object group
XY graph: Plot Area group
XY graph: Trace group
XY graph: X-Axis group
XY graph: Y-Axis group
Table Objects
Standard tables
Standard table: Alert group
Standard table: Background group
Standard table: Cell group
Standard table: Column group
Standard table: Column Header group
Standard table: Data group
Standard table: Data Label group
Standard table: Grid group
Standard table: Historian group
Standard table: Interaction group
Standard table: Label group
Standard table: Object group
Standard table: Row Header group
Standard table: Sort group
Rotated tables
Rotated table: Background group
Rotated table: Cell group
Rotated table: Column group
Rotated table: Data group
Rotated table: Grid group
Rotated table: Historian group
Rotated table: Interaction group
Rotated table: Label group
Rotated table: Object group
Trend Objects
Sparkline charts
Sparkline chart: Alert group
Sparkline chart: Background group
Sparkline chart: Data group
Sparkline chart: Data Format group
Sparkline chart: Historian group
Sparkline chart: Interaction group
Sparkline chart: Label group
Sparkline chart: Legend group
Sparkline chart: Marker group
Sparkline chart: Object group
Sparkline chart: Plot Area group
Sparkline chart: Trace group
Sparkline chart: X-Axis group
Sparkline chart: Y-Axis group
Stock charts
Stock chart: Background group
Stock chart: Data group
Stock chart: Data Format group
Stock chart: Interaction group
Stock chart: Historian group
Stock chart: Label group
Stock chart: Legend group
Stock chart: Object group
Stock chart: Plot Area group
Stock chart: Price Trace group
Stock chart: Trace group
Stock chart: TraceN group
Stock chart: X-Axis group
Stock chart: Y-Axis group
Trend graphs
Trend graph: Alert group
Trend graph: Background group
Trend graph: Data group
Trend graph: Data Format group
Trend graph: Interaction group
Trend graph: Label group
Trend graph: Legend group
Trend graph: Marker group
Trend graph: Object group
Trend graph: Plot Area group
Trend graph: Trace group
Trend graph: TraceN group
Trend graph: Trace Groups group
Trend graph: X-Axis group
Trend graph: Y-Axis group
Drill-Down Specification
Using the Drill Down Properties dialog
Activating drill downs
About drilldown displays opened in Dashboard Builder
Dashboard Function Reference
Introduction to Dashboard Functions
Working with functions
Scalar Functions
Add
Average
Boolean Expression
Concatenate
Correlator Time Format
Date Add
Date Ceiling
Date Compare
Date Difference
Date Floor
Date Format
Date Now
Delta
Divide
Duration
Evaluate Expression As Double
Evaluate Expression As String
Format Number
Get Substitution
Init Local Variable
isWindowsOS
Max
Min
Modulo
Multiply
Percent
Quick Set Sub
Replace All
Replace Value
Set Substitution
Set Substitutions By Lookup
Subtract
Validate Substitutions
Tabular Functions
Add All Rows Or Columns
Add Columns
Average All Rows Or Columns
Average Columns
Baseline Over Time
Buffer Table Rows
Combine
Concatenate Columns
Convert Columns
Copy
Count
Count By Bands
Count Unique Values
Count Unique Values By Time
Create Selector List
Delta And Rate Rows
Delta Rows
Distinct Values
Divide Columns
Ensure Columns
Ensure Timestamp Column
Evaluate Expression By Row
Filter And Extract Matches
Filter By Pattern
Filter By Row
Filter By Time Range
First Table Rows
Format Table Columns
Get Data Server Connection Status
Group By Time
Group By Time and Unique Values
Group by Unique Values
Join
Join Outer
Last Table Rows
Mark Time Gaps
Max All Rows or Columns
Max Columns
Min All Rows or Columns
Min Columns
Modulo Columns
Multiply Columns
Percent Columns
Pivot On Unique Values
Reference
Rename Columns
Select Column
Set Column Type
Sort Table
Split String
String to Table
Subtotal By Time
Subtotal By Unique Values
Subtract Columns
Table Contains Values
Expression Syntax in Dashboard Functions
Operators in dashboard function expressions
Arithmetic functions in dashboard function expressions
String functions in dashboard function expressions
Dashboard Deployment
Dashboard Deployment Concepts
Deployment options
Application installation
Authentication
Authorization
Data protection
Refresh latency
Scalability
Dashboard support for Apple iPad
Data server and display server
Process architecture
Builders and administrators
Generating Dashboards
Starting the wizard
Using the wizard
Using the titlebar/toolbar
Using the Introduction form
Using the Main, Create, Edit, and Details Forms
Using the layout configuration forms
Preparing Dashboards for Deployment
Dashboard feature checklist
Changing correlator definitions for deployment
Choosing among deployment types
Application installation
Authentication
Authorization
Data protection
Scalability
Choosing among Web-based deployment types
Installation
Served data
Refresh latency
Dashboard command support
Dashboard iPad Support
Using the Deployment Configuration editor
Starting the Configuration editor
Saving deployment configurations
Sections of the configuration editor GUI
Title bar/Toolbar
General Settings
Startup and Server
Additional JAR Files
Layout
Using the Dashboard Package wizard
Generating a deployment package from the command line
Sharing information with the Dashboard Administrator
Deploying Dashboards
Generating the dashboard .war file
Installing a dashboard .war file
Inside a dashboard .war file
Additional steps for display server deployments
Applet and WebStart Deployment
Managing the Dashboard Data Server and Display Server
Prerequisites
Starting and Stopping the Data Server or Display Server
Description
Options
Controlling Update Frequency
Configuring Trend-Data Caching
Managing Connect and Disconnect Notification
Working with multiple Data Servers
Builder with multiple Data Servers
Viewer with multiple Data Servers
Display Server deployments with multiple Data Servers
Applet and WebStart deployments with multiple Data Servers
Managing and stopping the Data Server and Display Server
Description
Options
Administering Dashboard Security
Administering authentication
Authentication for local and WebSphere deployments
Dashboard Login Modules Provided by Apama
Developing custom login modules
Installing login modules
Installing UserFileLoginModule
Installing LdapLoginModule
Administering authorization
Users and roles
Default Scenario and DataView access control
Customizing Scenario and DataView access control
Providing a Scenario Authority
Developing a custom Scenario Authority
Implementing IScenarioAuthority methods
Installing a Scenario Authority
Sample Custom Scenario Authority
Send event authorization
Using UserCredential accessor methods
Compiling your Event Authority
Installing your Event Authority
Providing a login module that supports a Scenario or Event Authority
Securing communications
Example: Implementing LoginModule
Using the Dashboard Viewer
Concepts Underlying Dashboards
About Dashboards
Starting the Dashboard Viewer
Scenario instance and DataView item ownership
Using the Dashboard Viewer
Opening and viewing dashboards
Running the Statistical Arbitrage demo
Displaying additional dashboards
Creating scenario instances visualized by the Statistical Arbitrage main dashboard
The Dashboard Viewer menubar
Resizing the Dashboard Viewer
Working with Dashboard Objects
Trend charts
Stock charts
Tables
Pie and Bar charts
Startup Options
Synopsis
Command line options
Timezone ID Values
Deploying and Managing Apama Applications
Overview of Deploying Apama Applications
About deploying components with EMM
About Apama command line utilities
About deploying dashboards
About tuning applications for performance
Setting up the environment using the Apama Command Prompt
Using the Management and Monitoring Console
Installation
Concepts
The EMM console window
Committed values and outstanding changes
State persistence
Managing licenses
Managing security
Managing hosts
Sentinel Agents
Sentinel Agent options
Working directory
Working with hosts
Managing all known hosts
Managing components
Component status indicators
Working with components
Add correlator
Add adapter
Remove component
Move component to host
Start component
Stop component
Restart component
Clear all component logs
Configuring components with the details pane
Specifying paths and filenames in the Details Pane
Preferences
Warnings
Display
Timing
Deploying and Configuring Correlators
Adding correlators
The correlator tabs
Management tab
Configuration tab
Initialization tab
Adding initialization actions
Connections tab
Adding new upstream connections
Downstream connections
Statistics tab
Inspect tab
Deleting Monitors, Event Types, or JMon applications from a correlator
Displaying event type definition for multiple Event Types
Diagnostics tab
Deploying and Configuring Adapters
Adding adapters
Configuring adapters
Specifying paths and filenames in the Details Pane
The Adapter tabs
Management tab
Configuration tab
Connections tab
Control tab
Statistics tab
Diagnostics tab
Deploying and Managing Queries
Overview of deploying and managing query applications
Query application architecture
Deploying query applications
Running queries on correlator clusters
Deploying queries on multiple correlators
Deploying BigMemory Terracotta Server Array
Configuring BigMemory driver
Using JMS to deliver events to queries running on a cluster
Mixing queries with monitors and scenarios
Handling node failure and failover
Managing parameterized query instances
Creating new query instances by setting parameter values
Changing parameter values for queries that are running
Monitoring running queries
Tuning Correlator Performance
Scaling up Apama
Partitioning strategies
Engine topologies
Event correlator pipelining
Connection configuration file
Configuring pipelining through the client API
Event partitioning
Managing and Monitoring over REST
Generic Management
Correlator Management
IAF Management
Correlator Utilities Reference
Starting the event correlator
About the Apama license file
Specifying log filenames
Examples for specifying log filenames
Descriptions of correlator status log fields
Text internationalization issues
Determining whether to disconnect slow receivers
Description of slow receivers
How frequently slow receivers occur
Correlator behavior when there is a slow receiver
Tradeoffs for disconnecting a slow receiver
Determining whether to disable the correlator’s internal clock
Injecting code into a correlator
Deleting code from a correlator
Packaging EPL and Java code
Sending events to correlators
Receiving events from correlators
Watching correlator runtime status
Inspecting correlator state
Shutting down and managing components
Viewing garbage collection information
Using the profiler command-line interface
Setting logging attributes for packages, monitors and events
Rotating the correlator log file
Rotating all log files
Rotating specified log files
Using the command-line debugger
Obtaining online help for the command-line debugger
Enabling and disabling debugging in the correlator
Working with breakpoints using the command-line debugger
Adding breakpoints
Listing breakpoints
Removing breakpoints
Controlling execution with the command-line debugger
The wait command
Command shortcuts for the command-line debugger
Examining the stack with the command-line debugger
Displaying variables with the command-line debugger
Replaying an input log to diagnose problems
Creating an input log file
Rotating an input log file
Performance when generating an input log
Reproducing correlator behavior from an input log
Event file format
Event representation
Event timing
Event types
Event association with a channel
Using the data player command-line interface
Using the Apama component extended configuration file
Binding server components to particular addresses
Ensuring that client connections are from particular addresses
Setting environment variables for Apama components
Setting log files and log levels in an extended configuration file
Sample extended configuration file
Starting a correlator with an extended configuration file
Release Notes
What's New In Apama 9.9
Installation changes in 9.9
Query enhancements in 9.9
Apama enhancements in Software AG Designer 9.9
EPL enhancements in 9.9
Correlator utility enhancements in 9.9
Dashboard enhancements in 9.9
Miscellaneous enhancements and changes in 9.9
New samples in 9.9 showing how to containerize Apama for Docker (Linux only)
Platform changes in 9.9
Renaming of Apama client libraries in 9.9
Miscellaneous changes in 9.9 affecting backwards compatibility
Removed and deprecated features in 9.9
What's New In Apama 5.3
New Apama queries capability
Apama Studio enhancements in 5.3
Log rotation enhancements in 5.3
EPL enhancements in 5.3
Correlator-integrated messaging for JMS enhancements in 5.3
Dashboard enhancements in 5.3
Killing an object now requires specification of a monitor name
New sample project showing how to manage Universal Messaging DataGroups
C++ and C Correlator plug-in API enhancements
Miscellaneous enhancements and changes in 5.3
Platform changes in 5.3
JDK 7 now minimum JDK version supported
Removed and deprecated features in 5.3
Backwards incompatibility with persisted projects recovered to 5.3 from older versions
What's New in Apama 5.2
Apama Studio enhancements in 5.2
New feature for addressing contexts with channels in 5.2
New feature for using Universal Messaging to connect Apama components in 5.2
New and changed EPL statements in 5.2
Enhancements to Apama adapters in 5.2
Changes to correlator utilities in 5.2
Windows compiler and .NET version updates in 5.2
Linux compiler updates in 5.2
Upgrading to Apama-supplied JDBC and ODBC database drivers in 5.2
Removed and deprecated features in 5.2
Miscellaneous enhancements and changes in 5.2
What's New in Apama 5.1.1
What's New in Apama 5.1
New distributed MemoryStore
New EPL exception handling mechanism
New support for managing and monitoring with REST APIs
New support for creating correlator plug-ins using Java
New headless mode generation of ApamaDoc
New support for PySys test framework
Dashboard login redirect file name has changed
New EPL keywords
Miscellaneous enhancements in 5.1
Support removed from Apama 5.1
Migrating Apama applications
What’s New in Apama 5.0.1
Linux runtime performance enhancement
Changes to the Apama Database Connector
Integrating JMon applications with Corticon
Correlator-integrated adapter for JMS bundle name changes
Improved profiling analysis
5.0 features now documented
Specifying Dashboard Builder options in Apama Studio
What’s New in Apama 5.0
Changes to EPL features in Apama 5.0
EPL changes without migration implications
EPL changes that might have migration implications
The com.apama namespace is restricted
New Apama client API support for decimal type
New ADBC adapter features
Packaged Progress database drivers
New Web Services client adapter features
New correlator-integrated messaging for JMS features
Event parser usability/type-safety improvements
Correlator Deployment Packages
New correlator startup option
Changes to engine_send
Deprecated serialize and deserialize operations have been removed
Deprecated high availability components removed
Changes in Apama Studio
Changes related to dashboards
Event Modeler standard block changes
Migrating from Apama 4.3
Platform changes between 4.3 and 5.0
Changes to Apama client APIs between 4.3 and 5.0
Migrating 4.3 projects that use Web Services Client adapters
API Reference for EPL (ApamaDoc)
API Reference for Java (Javadoc)
API Reference for .NET
PDF Documents
Copyright
Contact Us
Apama Documentation
Contact Us
tutorialEMintro
ImportWizard
ExportWizard
QUERY_CONDITIONS_WITHOUT_CLAUSE_DIALOG
PROFILER_CREATE_SNAPSHOT
tutorialMSmain
tutorialEventTypes
tutorialMonitors
tutorialSpawnMonitors
tutorialEventProcessOrder
tutorialComplexEvents
tutorialStreams
tutorialStreamsCrossJoin
tutorialRouteEvents
tutorialEmitEvents
tutorialConditionalLogic
tutorialMultipleMonitors
tutorialDictionary
tutorialPersistData
tutorialDataViews
tutorialEMstates
tutorialEMrules
tutorialEMvariables
tutorialEMblocks
tutorialEMinterface
tutorialEMwiring
PREFERENCE_PAGE_SCENARIOS
tutorialEMcustomblock
tutorialEMscenarioblock
tutorialJavamain
tutorialJavaEventTypes
tutorialJavaMonitors
tutorialJavaMonitorTemplates
tutorialJavaComplexEvents
tutorialJavaRouteEvents
ADD_COMPUTED_NODE_DIALOG
ASSIGN_TEMPLATE_DIALOG
XPathDialog
ArchiveEditor
CONDITIONAL_EXPRESSION_DIALOG
ADD_CLASSPATH_VARIABLE_DIALOG
dashboard_builder_context
tutorialDashboard
dashboard_viewer_context
emm_context