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) Java API
Description of Apama Studio
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 Studio’s Data Player
How the correlator works
Apama Concepts
Event-driven programming
Complex event processing
Understanding monitors and listeners
Understanding scenarios and blocks
Understanding dashboards
Getting Ready to Develop Apama Applications
Becoming familiar with Apama
Introduction to Apama Studio
Steps for developing Apama applications
Overview of starting, testing and debugging applications
Developing Apama Applications
Using Apama Studio
Overview of developing Apama applications
Samples and tutorials
The Apama interface
The Apama Workbench perspective
Workbench Project view
The Apama Developer perspective
Project Explorer view
The Apama Runtime perspective
Apama projects
Managing project hierarchies
Working with Apama projects
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 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 Apama Java applications
Adding a new Java application
Adding an Apama Java monitor
Adding an Apama Java event
Adding a Java EPL Plugin
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 Apama Java projects
Adding Apama Java applications
Adding Apama Java classes
Adding non-Apama Java files
Adding bundles to projects
Bundle instances
Adding adapters 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 Apama Studio 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
Exporting project information
Exporting a project initialization file list
Exporting a launch configuration
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
Internationalizing Apama applications
Checking the error log
Creating Blocks
About blocks
Introduction to block definition files
Description of block interface elements
How scenarios communicate with their blocks
Defining new blocks in Apama Studio
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
Launching Projects
Running Apama projects
Default launch configuration
Workbench perspective
Developer perspective
Defining custom launch configurations
Adding a correlator
Correlator arguments
Persistence options
Initialization
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
Creating new instances of scenarios
Viewing Scenario instances
Editing a scenario instance
Deleting a scenario instance
Deleting all scenario instances
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 Apama Java 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 Apama Studio
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 playback queries
Data Player Control view
Playback settings
Playback controls
Playback status
Creating query templates
Command-line Data Player interface
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
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 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
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
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
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
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 Apama Studio development environment
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
Allocating events
Event processing order
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
Sending events to other monitors
Defining your application’s message exchange protocol
Using events to control processing
About service monitors
Adding a bundle to your project
Utilities for operating on monitors
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
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
About timers and their trigger times
Understanding time in the correlator
Disabling the correlator’s internal clock
Generating events that keep time
About repeating timers
Setting the time in the correlator
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 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?
Obtaining context references
Spawning to contexts
Enqueuing an event to a particular context
Enqueuing 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 replay 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
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 Payload Extraction plug-in
Accessing the payload in the correlator
The direct-access functions
Parameters for primary direct-access functions
Secondary direct-access functions
Parameters for secondary direct-access functions
The indirect-access functions
Secondary indirect-access functions
Using the Time Format plug-in
Time Format plug-in format functions
getTime()
Time Format plug-in parse functions
parseTimeFromPattern()
Time Format plug-in compile pattern functions
getMicroTime()
Format specification for the Time Format plug-in functions
Using the Log File Manager plug-in
Plug-in functions
Events that can be routed to the LoggingManager monitor
Including the Log File Manager in a project
Loading the Log File Manager when deploying with the Management & Monitoring console
Using the MemoryStore
Introduction to using the MemoryStore
Overview of MemoryStore events
Overview of steps for using the MemoryStore
Adding the MemoryStore bundle to your project
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
Interfacing with user-defined correlator plug-ins
About the chunk data 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
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
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
EPL Naming Conventions
EPL Keyword Quick Reference
EPL Methods Quick Reference
action methods
boolean methods
chunk methods
context methods
decimal and float methods
dictionary methods
event methods
Exception methods
integer methods
listener methods
location methods
sequence methods
StackTraceElement methods
stream methods
string methods
built-in monitor methods
Apama EPL Reference
Introduction and Notation Conventions
Hello World example
Notation conventions
Notation for sequences of symbols
Notation for repetition of symbols
Notation for choices of symbols
Types
Primitive and string data types
boolean
decimal
float
integer
string
Reference data types
action
chunk
context
dictionary
event
Exception
listener
location
sequence
StackTraceElement
stream
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
Event listener definitions
Event lifecycle
Event listener lifecycle
Event processing order
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 diagram
Event expression operator precedence
Event channels
Monitors
Monitor lifecycle
Programs
Packages
The using declaration
Monitor declarations
The import declaration
Monitor actions
SimpleActions
Actions with parameters
Contexts
Plug-ins
Garbage collection
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 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
Postfix expressions
Action and method calls
The subscript operator [ ]
The new object creation operator
Unary additive operators
Multiplicative operators
Multiplication operator
Division operator
Remainder operator
Additive operators
Addition operator
Subtraction operator
String concatenation operator
Relational operators
Less-than operator
Less-than-or-equal operator
Equality operator
Inequality operator
Greater-than-or-equal operator
Greater-than operator
Shift operators
Left shift operator
Right shift operator
Logical operators
Logical intersection (and)
Logical union (or)
Logical exclusive or (xor)
Unary logical inverse (not)
Bitwise logical operators
Bitwise intersection (and)
Bitwise union (or)
Bitwise exclusive (xor)
Unary bitwise inverse
Expression operator precedence
Stream queries
Stream query window definitions
Stream source templates
Variables
Variable declarations
Primitive type variable declarations
Primitive-type initializers
Reference-type variable declarations
Action variable declarations
Chunk variable declarations
Context variable declarations
Dictionary variable declarations
Event variable declarations
Listener variable declarations
Location variable declarations
Sequence variable declarations
Stream 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
Ordinary operators
Arithmetic operators
Comparison operators
Logical operators
Event operators
Expression operators
Field 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
Names
Limits
Obsolete Language Elements
Old style listener calls
Old style spawn statements
Developing Apama Applications in Java
Overview of Apama Java Applications
Introducing Apama Java API concepts
About event types
Simple example of an event type
Extended example of a Java event type
Comparing Java 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 Java applications
Parallel processing in Java applications
Overview of contexts in Java applications
Using contexts in Java 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 Java applications
Using EPL keywords as identifiers in Java
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
The Concept of Time in the Correlator
Correlator timestamps and real time
Event arrival time
Getting the current time
About timers and their trigger times
Externally generating time events
About &TIME events
Repeating timers
About &SETTIME events
Developing and Deploying Java Applications
Steps for developing Java applications in Apama Studio
Java prerequisites
Steps for developing Java applications manually
Deploying Java applications
Removing Java applications from the correlator
Creating deployment descriptor files
Format for 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 Java applications
Sample Java applications
Apama Java API Reference
Building Dashboards
Introduction
About dashboards
Starting the Dashboard Builder
Starting Builder from the Windows Start menu
Starting Builder from Apama Studio
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
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
Creating row-leaf format control trees
Creating row-node format tree controls
Configuring tree control icons
Attaching a tree control icon to data
Configuring tree control type icons
Configuring tree control status icons
Specifying tree control properties
Specifying tree control background properties
Specifying tree control data display properties
Specifying tree control interaction properties
Specifying tree control label properties
Specifying tree control node structure properties
Specifying tree control object layout properties
Descriptions of unique tree control property behavior
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
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
Excluding tables From the Attach To SQL Data dialog
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
ODBC-JDBC bridge connection
Registering your database with ODBC
Using a database repository file
Excluding tables From the Attach To SQL Data dialog
Setting SQL data source options
Dashboard Property Reference for Graphs, Tables, and Trends
Introduction
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
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 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
Developing 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 Management – Managing a running adapter I
IAF Management options
IAF Management exit status
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
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 normalised 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
Java Transport Plug-in Development
The Java Transport Plug-in Development Specification
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 Java Codec Plug-in Development Specification
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 normalised events
The NormalisedEvent class
The NormalisedEventIterator class
Java Codec Example
Getting started with Java codec layer plug-in development
Java Plug-in Support APIs
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 Notification
Mapping example
Ordering of out of band notifications
The Event Payload
Creating a payload field
Accessing the payload in the correlator
Standard 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 normalised 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
Standard Apama Adapters
Apama File adapter
File Adapter plug-ins
File Adapter service monitor files
Adding the File adapter to an Apama Studio 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
Apama Database Connector (ADBC) adapter
Developing Clients
The Client Software Development Kits
Basic operations
The client software development kits
The C++ and Java Client Software Development Kits
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 JavaBeans API
The key elements
Overview of the EngineClientBean
Functionality of the EngineClientBean
Recommended usage
Logging
Delete operations
Inject operations
Inspect operations
Receive operations
Send operations
Watch operations
GenericComponentManagementBean
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
The .NET Engine Client Library
Using the .NET client library
Java and .NET namespace/class mapping
Writing Correlator Plug-ins
Introduction to Correlator Plug-ins
Writing a Plug-in in C and 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 data type
Working with chunk in C++
Working with chunk in C
Working with sequence
The complete example
Using complex_plugin from the event correlator
Asynchronous plug-ins
Writing correlator plug-ins for parallel processing applications
The EPL Plug-in APIs for C and C++
Primary class types
Listing of correlator_plugin.hpp
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
A more complex plug-in
A plug-in using enqueue
Deploying and Managing Apama Applications
Overview of Deploying Apama Applications
Deploying components with EMM
Using Apama command line utilities
Deploying dashboards
Tuning applications for performance
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
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 Java 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
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
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 and Monitoring over REST
Generic Management
Correlator Management
IAF Management
Event Correlator Utilities Reference
Starting the event correlator
Logging correlator status
Text internationalization issues
About the low latency and high throughput options
Determining whether to disconnect slow receivers
Description of slow receivers
Sending events to correlators
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
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
Using a replay log to diagnose problems
Comparison of full replay logs and input-only replay logs
Creating a replay log
Rotating the replay log
Command line examples for creating a replay log
Performance when generating a replay log
Reproducing correlator behavior from a replay log
Event file format
Event representation
Event timing
Event data types
Using the data player command-line interface
Tuning Correlator Performance
Scaling up Apama
Partitioning strategies
Engine topologies
Event correlator pipelining
Connection configuration file
Configuring pipelining through the client API
Event partitioning
Using the Apama Database Connector
Overview
Adding an ADBC adapter to an Apama Studio 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
The Apama Web Services Client Adapter
Web Services Client adapter overview
Adding a Web Services Client adapter to an Apama Studio 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
Template-based mapping
Combining convention and template mapping
Mapping complex types
Difference between doc literal and RPC literal WSDLs
Specifying a correlation ID field
Specifying transformation types
Specifying an XSLT transformation type
Specifying an XPath transformation type
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
Upstream multithreading
Specifying upstream multithreading transport properties
Web Services Client adapter artifacts
Correlator-Integrated JMS Messaging
Correlator-integrated JMS messaging overview
Correlator-Integrated JMS example applications
Key concepts
Getting started - creating an application with simple JMS messaging
Configuring connections
Adding JMS receivers
Configuring Receiver Event Mappings
Using conditional expressions
Configuring Sender Event Mappings
Using EPL to send and receive JMS messages
Getting started - creating an application with reliable JMS messaging
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
Dynamic senders and receivers
Durable topics
Receiver flow control
Monitoring Correlator-integrated JMS status
Logging JMS enabled correlator status
JUEL Mapping Expressions Reference
JMS configuration reference
Configuration files
XML configuration file format
XML configuration bean reference
Advanced configuration bean properties
Designing and implementing applications for JMS
Using correlator persistence with Correlator-integrated JMS
How reliable JMS sending integrates with correlator persistence
How reliable JMS receiving integrates with correlator persistence
Using the correlator replay log with Correlator-integrated JMS
Reliability considerations
Duplicate detection
Performance considerations
JMS performance logging
Sender performance breakdown
Receiver performance breakdown
Configuring Java options and system properties
Diagnosing problems when using JMS
JMS failures modes and how to cope with them
Managing the Dashboard Data Server and Display Server
Prerequisites
Starting 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
Dashboard access control
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 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
Using Dashboard Viewer
Concepts
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
What's New in Apama
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 plugins 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 Apama Java applications with Corticon
JMS adapter 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
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 JMS messaging 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
Apama Java API Reference
ApamaDoc Documentation
Apama PDF Documentation
Apama Glossary
action
activation
adapter
aggregate function
Apama Studio
batch
block
bundle
.cdp
CEP
context
correlator
correlator deployment package
correlator-integrated JMS messaging
.csv
dashboard
Dashboard Builder
dashboard data server
Dashboard Viewer
Data Player
data view
.ddf
.ddp
EDA
EPL
event
event collection
event listener
Event Modeler
event template
.evt
exception
IAF
Integration Adapter Framework (IAF)
JMON
listener
lot
Management and Monitoring
.mon
monitor
MonitorScript
partitioning
plug-in
.rtv
scenario
.sdf
sentinel agent
simulation
SmartBlock
stack trace element
standard blocks
stream
stream listener
stream network
stream source template
stream query
Web Services Client adapter
window
Copyright
Contact Us
Apama Documentation
Contact Us
tutorialEMintro
tutorialEMcustomblock
tutorialEMstates
tutorialEMrules
tutorialEMvariables
tutorialEMblocks
tutorialEMinterface
tutorialEMwiring
tutorialEMscenarioblock
tutorialMSmain
tutorialEventTypes
tutorialEventProcessOrder
tutorialMonitors
tutorialSpawnMonitors
tutorialComplexEvents
tutorialStreams
tutorialStreamsCrossJoin
tutorialRouteEvents
tutorialEmitEvents
tutorialConditionalLogic
tutorialMultipleMonitors
tutorialDictionary
tutorialPersistData
tutorialDataViews
tutorialJavamain
tutorialJavaEventTypes
tutorialJavaMonitors
tutorialJavaMonitorTemplates
tutorialJavaComplexEvents
tutorialJavaRouteEvents
dashboard_builder_context
tutorialDashboard
emm_context
dashboard_viewer_context