StreamBase Engine Configuration

Minimum number of dispatch threads. This property is optional and its default value is 10.

For example:

minimumDispatchThreads = 10

Long. Specifies the maximum number of dispatch threads. This property is optional and its default value is 2000. For example:

maximumDispatchThreads = 2000

Long. Specifies the maximum number of seconds to wait for a JVM to shut down before aborting it. This property is optional and its default value is 60. For example:

shutdownTimerSeconds = 60

Long. Specifies the number of timers that can be executing concurrently. This property is optional and its default value is 1. For example:

timerParallelism = 1

Long. Specifies the maximum timer resolution. This is the interval at which timers are examined. Higher resolution timers have more impact on system performance. This property is optional and its default value is 1000. For example:

timerResolutionMilliseconds = 1000

The scheduling policy for the JVM process. The valid values for the policy are SCHED_FIFO, SCHED_RR, and SCHED_OTHER. This property is optional. For example:

schedulerPolicy = "SCHED_FIFO"

Long. Specifies the scheduling priority for the JVM process. The valid range for priority depends on the policy; for Linux the valid values for SCHED_FIFO and SCHED_RR are 1 to 99. This property is optional and its default value is operating system-specific. For example:

schedulerPriority = 1

String. A path to an engine-specific data directory, which StreamBase operators, adapters, and other services use to store file data. The path can be absolute or relative; relative paths are relative to the value of the default engine data area location.

This path is created if it does not exist. If the path cannot be created or accessed, configuration audit fails. The data area can be changed at runtime by replacing a configuration with a new path. This location is never removed even if the data area is changed by replacing configuration, or the configuration is deactivated and removed.

This property is optional and has a default value of engine-data-area.

For example:

dataAreaPath = "engine-data-area"

The default folder name is created by default in the current node's node directory, in nodename/fragments/enginename/engine-data-area. See the configuration file in the Data Directory sample for examples of settings relative to the default path in Studio, and of absolute paths.

String. An association of global parameters to use in expressions in any module or container run by this StreamBase engine. This object is optional and has no default value. Operator parameters are legacy global variables, superseded by module parameters.

An operator parameter is specified by a name and a value. The name can be a simple name such as ParamOne. This will:

1. Expose a parameter available to modules using ${param} syntax. (This syntax also resolves to module parameters defined directly in modules, when present.)

2. Set the given value as the parameter value for any Java operator or adapter with a parameter of the given name.

The name can also be a dotted path name to set a particular adapter or operator's parameter, such as ContainerName.OperatorName.ParamOne. If the operator is in a submodule you must include the submodule in the dotted pathname, such as ContainerName.SubModuleName.OperatorName.ParamOne. When a path is used the parameter value will only be set for that named operator. All other parameters with the same name on other operators remain unmodified. See String Values in Parameters in the Authoring Guide for the recommended policy on quoting string parameter values.

This optional property is encryptable as part of the node-level secrecy system described in Encrypting Sensitive Configuration Data.

For example:

MyName = "MyValue"
"MyName.with.dots.quoted" = "#!v0hZ40tTIC1PKW8TrYdqyW81KLo2kH
   JG/GaYZ/K+1Z/UrhrlG1nfMFfuCJY+3Us4Vvt6jyAwiRcLk6aZN3vUXg=="

Bool. Set to true to force high resolution timers, at the expense of performance. This property is optional and its default value is false.

For example:

forceHighResolutionTimer = true

Bool. StreamBase's default behavior is to fail typechecking when an unbound capture is detected. An unbound capture occurs when an input stream of a module is implemented with a capture field and that input stream is not connected to an input port of the calling Module Reference in the parent application. This situation results in an error because there is no schema to examine or fields to capture for the unbound capture instance. When you are certain your unbound captures are benign, you can optionally suppress the resulting typecheck errors. To do this, set this key to true. This property is optional and its default value is false.

Long. The maximum size of a stream's schema; that is, the total number of bytes of all properties you expect in the tuple. While there is no theoretical upper limit, in practice there is a maximum based on the available memory on the machines that will host the processing of your application. Be cautious about creating very large schemas, because applications that move smaller amounts of data perform much better than applications that move tuples containing unnecessary fields. This property is optional and its default value is 1 megabyte.

For example:

schemaMaxSize = 1M

What implementation should be used for calls to now(). Must be either system or thread.

system uses a call to Java's System.currentTimeMillis(). thread uses a background thread that checks the time approximately every millisecond. This option results in decreased accuracy, but may be more efficient than system if you call now() more frequently than 1000 times per second. This property is optional and its default value is system.

For example:

nowImplementation = "thread"

Int. Each Java Operator changes state along with the engine process as a whole. The engine waits for each Operator to change state before it completes its state change. The value of this property is the amount of time the engine will wait before timing out the Operator. If an operator is timed out on a state change, the engine shuts the operator down and proceeds with the state change. This property is optional and its default value is 10000.

For example:

operatorStateChangeTimeoutMilliseconds = 10002

Configures the engine's monitoring subsystem. This property is optional.

Configures settings related to the Time Service. This property is optional and has defaults as specified below.

Configure the pluginFunctions object to register one or more custom functions with the containing EventFlow engine, and to optionally assign an alias to it, or to assign an alias to a method in any standard Java library class.

The syntax for this pluginFunctions object was extended in release 10.4.3 to provide a way to express multiple aliases for the same Java method. The extensions maintain compatibility with previous releases.

Note that you can use the expression language's calljava() function to call any custom function or standard library function by its fully qualified class and method name, as long as the class is accessible to to the current project's Maven search path. In this case, neither registering the function nor an alias name is required. Registering a function allows you to call it by its simple method name or alias name in expression language contexts.

This object is optional and has no default value. If used, it contains the single supported object java, under which is placed an array of Java methods, indexed by method name. For example:

configuration = {
  StreamBaseEngine = {
    streamBase = {
      pluginFunctions = {
        java = {
          calculate = {
            alias = "hypotenuse"
            autoArguments = true
            className = "com.tibco.ep.sample.Hypotenuse"
            type = "simple"
          }
          hypot = {
            alias = "hyp"
            autoArguments = true
            className = "java.lang.Math"
            type = "simple"
          }
        }
      }
    }
  }
}

Use the following table as a guide to help you port your function definitions from the 10.4.2 or earlier.

Default handling for runtime errors is to discard the error-producing event and continue with processing.

String. Constant values defined in a module may be overwritten with a value at engine startup time using this object. The object's values are constants and are substituted at engine startup time.

This optional property is encryptable as part of the node-level secrecy system described in Encrypting Sensitive Configuration Data.

For example:

constantsOverwrite = {
  constant1 = "value1"
  constant2 = "value2"
}

If an operator in an EventFlow module specifies that an artifact must exist before the operator is started, then this property configures how long to wait for the artifact from a TIBCO Artifact Management Server (AMS), before cancelling engine startup. This property is optional and its default value is 20000.

For example:

artifactWaitTimeoutMilliseconds = 20000

Configures runtime tracing for a StreamBase module. This is an example of data that could also be specified at deploy time via the override engine configuration.

Specifies the value of one or more parameters to be passed to the top-level module in the current container. This optional property is encryptable as part of the node-level secrecy system described in Encrypting Sensitive Configuration Data.

For example:

moduleParameters = {
  "param1.with.dots.quoted" = "value1"
  param2 = "value2"
}

An associative array of extension point target IDs and their contents. This property is optional and has no default value.

The name of an EventFlow or precompiled module file, which must exist in the fragment archive's module folder. This property is required.

For example:

moduleName = "mymodule.sbapp"

String. The name you assign to the container to hold the specified module. Container names must follow the StreamBase Identifier Naming Rules: names must begin with an alpha character or underscore, and can contain only alpha characters, numbers, and underscores. Names cannot contain hyphens, colons, or other non-alphabetic characters. For running or debugging in StreamBase Studio, the top-level module must be in a container named default. This property is required.

For example:

containerName = "mycontainer"

One of {ENABLED | DISABLED | DROP_TUPLES} to specify the startup state of dequeuing for this container. If you specify DISABLED, then dequeue attempts are actively refused and exceptions are thrown. If you specify DROP_TUPLES, then tuples are silently dropped. This property is optional and its default value is ENABLED.

For example:

dequeue = DISABLED

One of {ENABLED | DISABLED | DROP_TUPLES} to specify the startup state of enqueuing for this container. If you specify DISABLED, then enqueue attempts are actively refused and exceptions are thrown. If you specify DROP_TUPLES, then tuples are silently dropped. This property is optional and its default value is ENABLED.

For example:

enqueue = DROP_TUPLES

Set this value to true to specify that the module in this container should start up suspended. Set it to false to have the module start running when the container is added. This property is optional and its default value is false.

For example:

suspend = true

An address describing the entity in another named container (usually an output stream) that will send the data to the destination container. This property is required.

For example:

source = "zkMaintainModel.ModelUpdates"

An address describing the entity (usually an input stream) that will consume the output of the connected source container. This property is required.

For example:

destination = "default.ProcessTransactionAndScore.
  ProcessTransaction.EvaluateModel.default.Control"

A predicate expression filter to limit the tuples that cross to the destination container. The expression to enter must resolve to true or false, and should match against one or more properties in the schema of the connection's stream.

This property is optional and has no default value.

For example:

filter = "this is a filter"

By default, connections between containers are set up to run asynchronously, with a queue to manage the flow of tuples through the connection. StreamBase also supports synchronous container connections, which are low latency, direct connections between containers, and do not have queue management. This property is optional and its default value is ASYNCHRONOUS.

For example:

synchronicity = "ASYNCHRONOUS"