TIBCOs Complex Event Processing CEP Offering AGENDA Introduction to CEP amp Business Events Business Events Palette Overview Channels amp Destinations Events Concepts Rules amp Rule Sets ID: 529793
Download Presentation The PPT/PDF document "TIBCO Business events" is the property of its rightful owner. Permission is granted to download and print the materials on this web site for personal, non-commercial use only, and to display it on your personal computer provided you do not modify the materials and that you retain all copyright notices contained in the materials. By downloading content from our website, you accept the terms of this agreement.
Slide1
TIBCO Business events
TIBCO’s Complex Event Processing (CEP) OfferingSlide2
AGENDA
Introduction to CEP & Business Events
Business Events Palette Overview
Channels & Destinations
Events
Concepts
Rules & Rule Sets
ScorecardsSlide3
Situation Refinement
Patterns from historical data
Real time events
Detected & Predicted Situations
Complex event processing
“
CEP
is a set of technologies that allows “events” to be processed on a continuous basis
”
Slide4
Complex event processing
Typical Complex Event Processing Area
Situation awareness
Track and trace
Sense and respond
H A S
“These
aspects may overlap in actual business situations
”Slide5
Situation awareness
KNOWING
the state of product, person, document or entity of interest at any particular time
Requires continuous
MONITORING
of eventsEXAMPLEThe
REAL TIME DASHBOARD indicates all the performance indicators for a runtime production process.Slide6
Sense and respond
DETECTION
of
significant
fact about the product, person, document or entity of interest and
RESPOND accordingly
To achieve this, SYSTEM performs
a) MONITORING OF EVENTS
b) DETECTION OF SOMETHING SIGNIFICANT
c) EXECUTION OF REQUIRED RESPONSEEXAMPLE
Monitor credit card usage and detect that the credit card is being used consecutively at locations that are too far apart for real time person to business transactions. Fraud is detected and the transactions are denied.Slide7
Track and trace
TRACKING
the product, person, document or entity of interest over time
TRACING
pertinent facts like location, owner or general status
EXAMPLE
Tracking events from an RFID-enabled inventory control system where at any point in time you need to know the status of the delivery of goods at a particular locationSlide8
Business events major components
DESIGN
DEPLOY
RUN
Project Files
TIBCO Designer
WORKBENCH
STATE MODELER
TIBCO Business Events Server
TIBCO Administrator
R
untime Data Store
Browser
TIBCO Administrator
Browser
TIBCO Designer
WORKBENCH
EAR
File
Project FilesSlide9
model driven approach in Business Events
“ TIBCO Business Events enables CEP problems to be solved through a MODEL DRIVEN approach, in which the developer defines the event, rule, concept(class) and state models which are then compiled so that run time incoming events are processed efficiently as possible “
Describes
INPUTS
in BE
Describes BEHAVIORAL MECHANISM in BE
Describes DATA
in BEDescribes
STATES, TRANSITION & CONDITIONS in BE
EVENT MODEL
RULE & RULESET MODEL
CONCEPT MODEL
STATE MODELSlide10
AGENDA
Introduction to CEP & Business Events
Business Events Palette Overview
Channels & Destinations
Events
ConceptsRules & Rule SetsScorecardsSlide11
Business events Palettes
Business Events Workbench Palette mainly consists of :
Channel – Destination
Concept
Concept View
Simple Event & Time Event
Score Card
Rule Set – Rule
Rule Function
Business Events Activities Palette mainly consists of : Receive Event
Send EventWait for EventInvoke Rule FunctionRule Service Provider Configuration
Business Events State Modeler Palette mainly consists of :
State Machine
Call State Machine
Simple
Composite
Concurrent
Annotation
EndSlide12
AGENDA
Introduction to CEP & Business Events
Business Events Palette Overview
Channels & Destinations
Events
ConceptsRules & Rule SetsScorecardsSlide13
Channels & destinations
CHANNEL
DESTINATIONS
“CHANNELS represent physical connections to a resource”
“DESTINATIONS in a channel represent listeners to MESSAGES from that resource”
MESSAGESSlide14
Architecture : Channels & destinations
TIBCO EMS
orders
credit
new_order
credit_timeout
Channel
Destination
Subject: orders
Subject: credit
Default
Destination
map to
Default Event
Event
Serialization
DeserializationSlide15
Channels & destinations
“Channels represent physical connections to a resource”
“Destinations in a channel represent listeners to messages from that resource”Slide16
Types of channels
TIBCO Rendezvous Channels
Connects BE to RV sources & sinks
.
JMS ChannelsConnects BE to EMS sources & sinks.Local ChannelsConnects multiple rule sessions at runtime.Slide17
AGENDA
Introduction to CEP & Business Events
Business Events Palette Overview
Channels & Destinations
Events
ConceptsRules & Rule SetsScorecardsExampleSlide18
What is an Event?
ACTIVITY
that happens.
EXAMPLE:
Kicking a ball
.
Speed
DirectionDistance
Ball TypeEvent Type
Speed
DirectionDistance
Ball Type7km/hr
East
12m
football
Instance
In Complex Event processing the term
Event
is overloaded. It means the definition of object that represents the activity (
Event type) and also an
Instance
of that event type.Slide19
Business Events
Working
Memory
What happens when an event instance is created?
Event
Working
Memory
1) Memory Assertion
Events that are created from incoming messages, are automatically asserted into working memory.
At runtime, event instances that are created using rules are not automatically asserted into working memory. You must explicitly assert such events, for example using the Event.assertEvent() function.
Create Event instance
External
Environment
Automatic
ExplicitSlide20
2) Memory Acknowledgement
Depending upon the object management type BusinessEvents acknowledges the message.
Some messages do not require acknowledgement.
e.g.: Reliable Rendezvous messages.
What happens when an event instance is created?Slide21
Types of events
Events
Advisory
Time
Simple
Repeating Time
Rule BasedSlide22
Simple Event
Life of an Event
Event
Expired!
Time to Live
Time To Live (TTL)
Time To
Live
Event
Expiration
Zero
After completion of first
RTC Cycle.
Positive
After
specified time period has elapsed.
Negative
Does not expired. Must be explicitly consumed.
Expiry Action
Any
Action(s)
possible to define in
Rule language,
to take when a simple event
expires
.
Expiry actions can be inherited from event’s parent.
If an event is explicitly consumed in the rule, BusinessEvents does not execute the expiry action.Slide23
Simple Event
Event Inheritance/Inherits from
Inherits
Properties
Expiry Actions
Expiry Actions set in child Event overrides the parent event Expiry Actions.
Parent Event can NOT have payload.
Can NOT have distinct properties with same name.
?Slide24
Simple Event- how the event data is carried?
Properties
Payload
SIMPLE
EVENT
Extended Properties
has data types. e.g.: String,int,boolean
has complex data structures. e.g.: XML Schema
are usedinternally & it is reserved for future release.Slide25
Types of events
Events
Advisory
Time
Simple
Repeating Time
Rule BasedSlide26
Time events
TIMERS, that are used to trigger rules.
Repeat Every
Rule Based
Creates a new time event after every specified time interval.
Creates specified number of events at each time interval.
ScheduleTimeEventName()
function is used inside Rule, to create a new time event.Slide27
Types of events
Events
Advisory
Time
Simple
Repeating Time
Rule BasedSlide28
Advisory events
Advisory Events
are asserted into the memory when certain conditions occur.
It has attributes for
category, type & message.
Exception
Engine Activated Advisory Events
BusinessEvents-ActiveMatrix
BusinessWorks Integration
Category: ExceptionType: Exception class nameMessage: Message in class.
Category: EngineType: engine.primary.activatedMessage: Engine <EngineName> activated.
Category: EngineType: INVOKE BW PROCESS
Message: Error message from failed BW Process.
1
2
3Slide29
AGENDA
Introduction to CEP & Business Events
Business Events Palette Overview
Channels & Destinations
Events
ConceptsRules & Rule SetsScorecardsSlide30
Concepts
Concepts
are descriptive entities similar to the object-oriented concepts of a class.
Department
Name
CodeManager
Employee
External Environment
Event
CodeManagerEmployee
Working
Memory
Department
Car
Pen
Insert.deleteInstance()
Insert.createInstance()
Concepts are automatically asserted into working memory when created, except when concepts are returned by Database query & in the context of in-process integration.
Concepts needs to be explicitly deleted.Slide31
concepts
Historical Values
for a concept property are kept in a ring buffer.Slide32
concepts
History Policy
0—0—0—36—25—10—10—0Slide33
Concept relationship
Concept Relationship
Reference
Containment
InheritanceSlide34
Concept relationship
Wheel
Diameter
Vendor
Rim Type
Material
Bike Wheel
- -
-- -----------
Inherits
Contains
Car Wheel
Car
Car Wheel
Car
Motorbike
Color
Vendor
Make
Model
Engine
Wheel:Contains
Car
CustomerID
OrderID
OrderDetails
Customer
Refers
Car Wheel
-
-
--
---------- Slide35
AGENDA
Introduction to CEP & Business Events
Business Events Palette Overview
Channels & Destinations
EventsConcepts
Rules & Rule SetsScorecardsSlide36
Actions
Rules
Conditions
Declaration of Entity Types
RULE
=
+
+
“A Rule includes a declaration of entity types, one or more separate conditions , which evaluate to true or false, and an action, which is eligible to execute only when
ALL
the conditions evaluate to true”
Rule Priority
“ Use priorities prudently”Slide37
A Typical ruleSlide38
Rule sets
A rule set is a container for rules.
All rules exist within a rule set.
Grouping rules into rule sets enables you to deploy a selection of rule sets in a Business Events Archive (BAR).
EXAMPLE
:
As
seen in the picture, different colored pebbles are contained by different mesh bags. So mesh bag becomes the rule set that contains pebbles which are the rules.Slide39
Rule functions
Function for a use at a project level.
Not contained in a rule set.
Mainly 4 types of rule functionsSlide40
AGENDA
Introduction to CEP & Business Events
Business Events Palette Overview
Channels & Destinations
EventsConcepts
Rules & Rule SetsScorecardsSlide41
scorecards
Serves as a static variable which is available throughout the project.
Unlike concepts and events, each scorecard resource is itself a single instance.
Use a scorecard resource to track Key Performance Indicators (KPI) or any other information.Slide42
AGENDA
State Modeler
Database Concepts
Out & In Process IntegrationSlide43
State Modeler
UML-compliant application.
Used to model the life cycle of an instance of concept.
Example:-
Project Life Cycle.
Classify Orders.
Defines transition from state to state based on rules that apply.
To model the life cycle a
state machine resource
is used. Within a state machine resource you can configure the states and transitions.Slide44
State Model
Each
State model
begins with
start state
and ends with one or more end states .
Between these states may be simple, composite and concurrent
states connected by transitions.Slide45
State Machine Resource
Exists Within
State Machine
Concept
Instance of Main state Machine
calls
one
At most one
Exists Within
Call State machineSlide46
Modeling Order Process
Customer places Order
Accounting
performs credit check
Customer passes Credit check
Warehouse checks Inventory
Warehouse finds the item in stock
Item sent for Shipment
Customer receives the ItemSlide47
Main State Machine
Parent Concept
Inherits from
Child Concepts
State MachinesSlide48
CALLS CHILD STATE MACHINE
Parent State Machine
Child State Machine
State Machine
Recursive calls to state Machines not Allowed!
Call to state machine in lower inheritance chain not Allowed!Slide49
State Machine statesSlide50
states
START
Exit Action
END
Entry Action
SIMPLE
Exit Action
Entry ActionSlide51
Composite STATE
Fulfillment Process
Credit Check (Composite State)
Composite States are like nested folders.
Composite States can contain simple states, other composite states and concurrent states.Slide52
Composite STATE
Fulfillment Process
Credit Check (Composite State)
State2
State1
Composite State
FAILED
FAILS
Composite States are like nested folders.
Composite States can contain simple states, other composite states and concurrent states.Slide53
Concurrent State
Multiple processing lanes
Allows multiple state flows to operate at one time.
A state machine cannot exit a concurrent state until all its region have finished processing.
Can contain composite , simple states.Slide54
AGENDA
State Modeler
Database Concepts
Out & In Process IntegrationSlide55
Database concepts
Tables
Views
Relationships
DB Import
Utility
Business Events
DB Concept
Database
Insert
Update
Delete
Query
Database Concepts enable you to manipulate the database using a rule or rule function.
Relational
World
Object to Relational Mapping
Object
WorldSlide56
AGENDA
State Modeler
Database Concepts
Out & In Process IntegrationSlide57
Out-of-process Active Matrix business works Integration
Enables you to send and receive Business Events events in an Active Matrix Business Works engine.
Both engines run in separate JVMs.
Business Events Engine
Business Works Engine
Enterprise and External Resources
JMS/RV channelSlide58
Out-of-process Active Matrix Business Works integration ActivitiesSlide59
In-process active Matrix business works integration
Enables you to integrate ActiveMatrix BusinessWorks and Business Events functionality in one JVM.
Enables each product to take advantage of the strengths of the other product.
ActiveMatrix BusinessWorks can use Business Events as a light-weight rules engine.
BusinessEvents can use transports available in ActiveMatrix BusinessWorks.
ActiveMatrix Business Works
Business Events
JVMSlide60
All input and output is done through Business Events.
The BusinessWorks engine cannot communicate with resources outside of the BusinessEvents container.
All input and output is done through Business Works.
The BusinessEvents engine cannot communicate with resources outside of the BusinessWorks container.
Less management overhead
Simplifies maintenanceSlide61
Business Works Features
Business Works process
Business Events Rule Function
Uses
To call
Invoke Rule Function Activity
Passes concept/event /object
Rule service Provider Configuration (Required only when BW container)
Used to identify the location of Business Events application at runtimeSlide62
Business Events functions
BusinessWorks.cancelProcess()
-- Cancels the specified BusinessWorks
process.
-- Useful for canceling a long running job
. BusinessWorks.shutdown() (Optional)
--Shuts down the BusinessWorks processengine.Slide63
Design considerations related to containerSlide64
AGENDA
Introduction to Object Management And Fault Tolerance
In Memory Object Management
Persistence Object Management
Cache Object ManagementSlide65
Object management
OM is used to manage the
state of Ontology objects
(concepts, state machines, scorecards, simple events and time events) that are created and used by each Rete network
.
Three main Options for Object Management
In Memory
Persistence
CacheSlide66
Fault Tolerance
Fault tolerance mechanism differs with each of the OM options.
In Memory-
FT is provided at the engine level.
Configuration uses various engine properties to define primary and secondary engines.
Cache-
FT is provided at the inference agent level. With multi-engine features enabled, fault tolerance and load balancing are provided by the same set of features.
Persistence-
Fault tolerance requires a custom solution.Slide67
Overview
Partitioned :
The ability to partition the objects among multiple JVMs
.
Persistence of Objects :
Enables objects to be available for reuse, either in memory caches or in databases.Data Recovery : Ability to survive failures.
Clustered : The ability to maintain multiple copies of each object in differentnodes such that if one node fails, another node can take over.
Default optionSlide68
AGENDA
Introduction to Object Management
In Memory Object Management
Persistence Object Management
Cache Object ManagementSlide69
In memory Object management
FT
FT
FT Cache
Primary server
Secondary server
Rete n/w
Rete n/w
Fault Tolerance Cluster
of two engines using in memory OM
Total System Failure
NO Recovery Possible
Object state is not maintained
Objects are managed in memorySlide70
Fault tolerance for in memory om
BusinessEvents offers
priority-based fault tolerance
to provide high availability of the BusinessEvents engine process.
Fault tolerance provides transitioning between inactive and active states.
If two servers have the same priority setting, then the server that joined the group first takes priority in determining the failover and failback order.Slide71
Failover behavior(in memory OM FT)
FT
FT
FT Cache
Primary server
Secondary server
Rete n/w
Rete n/w
Fault Tolerance Cluster
of two engines using in memory OM
Primary Server
When a node fails, the node with the next highest priority assumes
responsibility for that node’s work.Slide72
Failback behavior(in memory OM FT)
FT
FT
FT Cache
Last Primary server
Secondary server
Rete n/w
Rete n/w
Fault Tolerance Cluster
of two engines using in memory OM
Primary Server
When a node restarts , it assumes responsibility from the node with the next lowest priority.Slide73
Steps to Configure FT in in memory om
Open the
BE_HOME\bin\be-engine.tra
file in text editor.
Configure following properties with same values for all engines.
Engine.FT.UseFT true Engine.FT.GroupName group nameIn each engine property file provide the unique engine name
be.ft.nodename Configure the weight properties to define priorities among servers. Secondary Servers will have lowest priorities.
Engine.FT.Weight integerSlide74
AGENDA
Introduction to Object Management
Memory Object Management
Persistence Object Management
Cache Object ManagementSlide75
Persistence object management
The PERSISTENCE object management option persists a snapshot of the working memory for each inference agent in the deployed system.
Data for each inference agent is persisted to a data store at specified intervals.Slide76
persistence object management cache
“ Small cache for each inference agent ensures that currently used objects are available in memory for improved performance. “
”
YOU CAN
CONTROL THE SIZE OF THE CACHE”Slide77
persistence OBJECT MANAGEMENT working
Provides data recovery in the case of a complete system failure.
When system comes up, BE restores the working memory to the last check point state.
Receives all of the previously unacknowledged messages.
Data in memory at the time of failure and not yet written on this disk is LOST.Slide78
persistence object management
Affects performance due to disk writes required.
Fault Tolerance features are not
provided
by BusinessEvents.
Parameters such as checkpoint interval and property cache size helps us to tune performance.Can also determine how many objects to keep in the data cache, in order to manage JVM memory usage for the application for better performance.Slide79
Uncheck this field to use the persistence database to recover from unplanned system shutdown.
Performance INCREASES, but data is lost in event of SYSTEM FAILURE.
When objects are retracted(deleted) from the memory, they are marked with a retraction flag.
You can delete these objects from the persistence DB, or you can leave them in the DB.
Recommended that you delete these retracted objects to avoid accumulating large numbers of retracted objects in DB, but you can keep them for data mining purposes.
Defines the maximum number of concept properties that are kept in the JVM memory for this rule session.
When the persistence layer performs cleanup, the least recently used(LRU) properties are moved to the persistence store, to reduce the number of properties in memory to the specified number.
A checkpoint is the point in time at which the working memory data is written to disk.
The checkpoint interval is the time, in seconds, between writes to disk.
persistence object management properties
Database operations include object creations, updates, and deletions.
Outstanding database operation is one that is held in working memory only.
It has not yet been written to the disk.
When the number of outstanding DB ops exceeds that of the number specified, a checkpoint occurs
DEFAULT PATHS where PERSISTENCE FILES are stored
BE_HOME/
db
/
session_name
: TIBCO Administrator
w
orking_directory
/
db
/
session_name
: BE EngineSlide80
Using checkpoint interval & outstanding
db
ops
30 SECONDS
CHECKPOINT INTERVAL
5
OUTSTANDING DATABASE OPERATIONS
30 SECONDS
INTERVAL
3
DATABASE
OPERATIONS
CHECKPOINT
10 SECONDS
INTERVAL
6
DATABASE
OPERATIONSSlide81
AGENDA
Introduction to Object Management
Memory Object Management
persistence Object Management
Cache Object ManagementSlide82
Cache Object Management
Object Management
refers to managing the state of ontology object instances created by each inference agent.
Cache Server
Inference
Agent
- Manage data objects
- Handles recovery
Rete
n/w
External Environment
Event x
Event y
Event z
a b c d eSlide83
Cache Server
1
Cache Server
2
Inference
Agent
Rete
n/w
External Environment
Event x
Event y
Event z
Cache Object Management
Distributed Cache
a
b
c
d
eSlide84
Cache Server
1
Cache Server
2
Inference
Agent 1
Inference
Agent 2
a
b
c
d
e
Cache Cluster
Inference
Agent 3
External Environment
Rete
n/w
Rete
n/w
Rete
n/w
Cache Object Management
Cache Cluster with Load Balancing
Event x
Event y
Event z
requires point to point communication!Slide85
Cache Object Management
Cache Cluster with Fault Tolerance
Cache Server
1
Cache Server
2
Inference
Agent 1
Inference
Agent 2
a
b
c
d
e
Cache Cluster
Event x
Event y
Event z
External Environment
Rete
n/w
Rete
n/w
Rete
n/w
Inference
Agent 3Slide86
Cache Object Management
Cache Cluster with Fault Tolerance
Cache Server
1
Cache Server
2
Inference
Agent 3
Inference
Agent 2
a
b
c
d
e
Cache Cluster
Event x
Event y
Event z
External Environment
Rete
n/w
Rete
n/w
Rete
n/w
Inference
Agent 1Slide87
AGENDA
Understanding Run to Completion (RTC) Cycle & Conflict Resolution
Startup & Shutdown Rule Functions
Event Preprocessor Rule functions
Virtual Rule Functions
Rule Analyzer & DebuggerRule ProfilerSlide88
Understanding run to
completion (RTC
) cycle
External action changes working memory
Business Events builds the agenda
BusinessEvents
executes the first rule action on the agenda and removes it from the agenda
BusinessEventsrefreshes the
agenda
RTCends
Does the action
change working
memory
?
Is the agenda empty ?
YES
YES
NO
NOSlide89
Begins
when an external action causes changes to working
memory
One
RTC cycle ends when there are no more rule actions to execute as a result of that initial change
. This is also known as forward chaining, or inferencing.During one RTC no new external actions can affect the working memory. An RTC is composed of one or more
conflict resolution cycles.Understanding run to completion (RTC) cycle Slide90
Understanding run to
completion (RTC
) cycle
External action changes working memory
Business Events builds the agendaSlide91
Working
Memory changes
When a message arrives at a destination, the working memory changes.
First conflict resolution cycle begins.
Business Events builds the agenda
Business Events examines all rules that are newly true because of the change to working memory and compares them with rule dependencies.The agenda’s entries are ordered according to rule priority and other criteria.
Understanding run to completion (RTC) cycleSlide92
Understanding run to
completion (RTC
) cycle
External action changes working memory
Business Events builds the agenda
BusinessEvents
executes the first rule action on the agenda and removes it from the agenda
Does the action
change working
memory
?
YES
NO
BusinessEvents
refreshes the
agendaSlide93
Business Events
executes the first rule on the agenda and removes it from
the agenda
The
rule action does not change working memory and Business Events executes
the next rule entry in the agenda (if there is one). ORThe rule action does change working memory and Business Events refreshes the rule action agenda to account for the changes.
Understanding run to completion (RTC) cycleSlide94
Business Events refreshes the agenda
Rules that have become newly true are added to the agenda
.
OR
Rules that have become false are dropped from the agenda. ORRules that were newly true at the last conflict resolution cycle and are still true remain in the agenda
.
Understanding run to completion (RTC) cycle
“As a result, either the agenda is empty and the RTC ends, or the first rule in the refreshed agenda is executed and a new cycle of conflict resolution begins.”Slide95
Understanding run to
completion (RTC
) cycle
External action changes working memory
Business Events builds the agenda
BusinessEvents
executes the first rule action on the agenda and removes it from the agenda
BusinessEventsrefreshes the
agenda
RTCends
Does the action
change working
memory
?
Is the agenda empty ?
YES
YES
NO
NOSlide96
An
empty agenda ends the
RTC
At some point, no more actions remain to
be executed. The conflict resolution has run to completion.
At the end of one RTC, the following happensEvents are sent to destinations.Cache OM: Changes are saved to the cache and written to the backing store.Cache OM, cache-only cache mode: At the end of the RTC, all cache-only objects are removed from working memory.
Persistence OM: One transaction is completed and saves changes (enabling rollback in case of failures).Profiler: profiler data is updated.
Understanding run to completion (RTC) cycleSlide97
How a rule becomes
newly true
A rule is
newly true if it has become true due to a change in working
memory. A rule that was already true can also become newly true.
A rule remains newly true until it is executed or it is removed from the agenda, or the RTC ends.
CONDITIONRuns.scored < 100
Runs.scored
= 90
Runs.scored
= 95
NEWLY TRUE
NEWLY TRUE
ALREADY TRUESlide98
How conflict resolution uses rule dependencies
Before any data enters into the system, BE builds a Rete Network, which has all the rule dependencies, using the rule conditions.
All dependencies in a rule are called its
dependency set,
which is the only thing needed to determine the truth of all the conditions.
customer.name == “James”;
person.name == “John”;hasAllAccess
(customer);DEPENDENCY SET
A
BSlide99
TESTING THE TRUTH of a rule’s condition using Dependency set
Business Events tests each rule’s dependency set against new set of facts.
If facts match the rule dependencies, the rule action is added to the rule action agendaSlide100
Order of evaluation of rule conditions
1
2
3
LEAST EXPENSIVE OPERATIONS
MOST EXPENSIVE OPERATIONSSlide101
AGENDA
Understanding Run to Completion (RTC) Cycle & Conflict Resolution
Startup & Shutdown Rule Functions
Event Preprocessor Rule functions
Virtual Rule Functions
Rule Analyzer & DebuggerRule ProfilerSlide102
Startup & shutdown rule functions
Configured to execute during normal system startup and shutdown.
Used to initialize the system & perform more “expensive” operations so that the system is more efficient at runtime.
TAKE NO ARGUMENT
VALIDITY
ACTION
1
2Slide103
STARTUP & SHUTDOWN RULE FUNCTIONS
Configure these functions in the
BUSINESS EVENTS ARCHIVE