Live Datamart New and Noteworthy Archive

Starting with release 2.0.6, author-time aggregation tables configured with case-insensitive string primary keys now always result in the case-insensitive string appearing in lowercase. In previous releases, case-insensitive primary key fields did not always appear in lowercase. An additional change is that the case sensitivity of the primary keys of an author-time aggregation table must match the case sensitivity of the corresponding base table.

LiveView administrators can now manage the exclusion of SSL protocols and cipher suites by using two new system properties, as discussed in Using SSL with LiveView Server in the LiveView Administration Guide. This feature is important in view of the Chrome browser's new default restrictions on connecting to servers that use the DHE cipher suite or older SSL protocols. Administrators can exclude those suites and protocols from the embedded Jetty server in the LiveView server, which allows default-configured recent Chrome and Firefox browser versions to connect to LiveView resources.

The LiveView Query adapter has a new option, Include input tuple in output, to include the tuple received on its QueryIn input stream with every result set output.

In previous releases, on any Mac with OS X Yosemite or later, double-clicking one of the DMG distribution files that contains StreamBase plus Live Datamart, or LiveView Desktop, could start a spinning beach ball timeout period that could last for many minutes. An alternate installation method was described in the Installation Guide.

Starting with release 7.5.5, TIBCO StreamBase DMG files now have a workaround for the Apple bug that was creating this situation. Thus, this issue is now completely resolved, and no longer requires the alternate installation method.

Services-only servers deployed from 1.6.5 and earlier, or from 2.0.0 through 2.0.4 installations cannot interact with LiveView 2.1.x full servers. However, services-only servers from a 1.6.6 or later installation, or a 2.0.5 or later installation, can interact with a 2.1.x full server.

StreamBase EventFlow modules from StreamBase 7.5.4 or earlier that incorporate a LiveView Query adapter cannot send a query to a LiveView 2.1.x server if the query contains a calculated column. However, such modules from StreamBase 7.5.5 and later can successfully send calculated column queries to a LiveView 2.1.x server.

This release supports a new parameter, default-query-limit-override, that can be added to an LVconf that defines a TIBCO ActiveSpaces external data provider. Such LVconfs also now support parameters that support ActiveSpaces authentication. These new parameters are illustrated in the ActiveSpaces Metaspace LiveView sample.

A new field rules sample is a version of the Hello LiveView sample that demonstrates a number of field rule definitions. Search for "field rules" in the Load StreamBase Samples dialog.

This new LiveView sample illustrates LiveView recovering from a service interruption using TIBCO EMS as the publishing bus. The LiveView Orders table is configured to use persistence and it has a publisher interface with an EMS message bus subscriber that is configured with a durable subscription. After LiveView service interruption and restart, LiveView recovers from disk almost all of the rows that were in the Orders table at the time of the interruption.

This sample is much like the EMS sample above, except it demonstrates LiveView recovery using TIBCO FTL as the publishing bus.

In the LiveView Java Client API, most of the QueryConfig setter methods return this, but a few of them returned void. As of this release, all QueryConfig setter methods now return this, which allows all methods to be chained.

The LiveView JavaScript Client API was updated to support deleting table rows. There is a new API function deleteRows(tableName, predicate, settings). In addition, queries against LiveView data tables from a JavaScript client now support the following syntax when run from LIveView.connection.execute:

DELETE tableName
DELETE FROM tableName [WHERE ...]

LiveView Desktop now keeps log files that preserve information about session connections and other events. Desktop end-users do not normally need to interact with these log files, but TIBCO Support or your site's LiveView Server Support Team might ask you to retrieve and send a log file.

The SnapshotQueryListener can now have its system wide data queue capacity changed by setting liveview.client.snapshotquerylistener.default.capacity=nnn, where nnn is an integer number of bytes. Individual SnapshotQueryListeners can have their data queue capacity set with a new constructor parameter.

The lv-client listtable command has several improvements in this release:

The following methods are deprecated as of release 2.0.4 and are expected to be removed in the next minor release of Live Datamart:

In addition to the full JavaScript Client API Documentation incorporated into the Live Datamart documentation set, JavaScript Client API documentation is also embedded in every running LiveView Server. Starting with this release, the relative URL for the embedded JavaScript Client API documentation is deprecated at its old address of /lv-web/api and is now available on /lv/api. For example: http://localhost:10080/lv/api

TIBCO LiveView Desktop was rewritten to use Eclipse 4.4 as its base, the same Eclipse base as StreamBase Studio. In general, this change is expected to be transparent to end-users, and LiveView Desktop connects to a LiveView Server instance and displays both textual and graphical views of LiveView tables just as before. However, several important behavior changes follow from this update, as noted in the following points.

Release 2.0.0 brought support for compression of non-streaming traffic between a LiveView Server and client, and new Java and .NET methods were made available to enable this feature in your client code. Starting with the current 2.0.3 release, compression is also available, and is the new default behavior, for streaming traffic as well.

The syntax of the lv-client delete command was changed to more closely resemble standard SQL. As such, it now interprets a FROM token as in this example:

lv-client delete [from] TableName [predicate-clause]

For backwards compatibility, the FROM keyword can be omitted, but it may be required in future releases.

A new command-line utility, lv-store-vacuum, scans a LiveView table's persistence log directory and consolidates all row entries into a temporary log file that preserves only the most recent state of each row. The command then moves the just-read log files to a backup directory, and renames the temporary log so that it will be used automatically if LiveView Server must begin an automated recovery procedure. This feature and the new command are described in a new section of the EventFlow Publish Applications page, Periodic Compression of Recovery Files.

This release includes a complete rewrite of the Dashboard sample included as one of the four web apps in the lv-javascript sample package. The new sample now serves as a model of best practices for customers writing web apps that display information from LiveView Server, using the LiveView JavaScript API. The new Dashboard sample uses MVx architecture, reusable visualizations, and a LiveView Query Service that manages queries and shares a common connection to the server. The sample allows users to define what gets displayed in the dashboard via a JavaScript object that serves as the model for the application. The chart visualization is based on a generic Highcharts.js wrapper that can be configured to display most Highcharts.js chart types.

To see the sample in action, load the Creating web applications with JavaScript sample in Studio, start LiveView Server against that project folder, then connect a web browser to http://localhost:10080/dashboard.

The Schema tab of the LiveView Configuration Editor for Data Tables was updated to support a mix of locally defined fields with fields imported from an EventFlow file or from a StreamBase interface file. Imported fields are read-only and are marked with a small triangle symbol.

The Field Rules tab of the LiveView Configuration Editor for Data Tables was extended with drop-down boxes to simplify choosing relevant field or variable names. The tab now supports the creation of new variables for use in the table's insert-update rules.

The LiveView Configuration Editor now bolds the titles of tabs that contain user-defined content, which echos the same feature in the EventFlow Editor.

In previous releases, the LiveView Configuration Editor did not support opening lvconf files that contained valid XInclude directives, directing you instead to use the text-based LiveView Configuration File Editor. This release loosens the restriction somewhat, allowing you to open and view such files in the LiveView Configuration Editor. This makes it possible to see the complete context of a configuration across all of the files that comprise it. However, the LVconf Editor opens such files in read-only mode, and you cannot save any changes made to the configuration in this mode.

Starting with release 2.0.2, you can perform simple field renaming when defining an author-time aggregation table. This adds to author-time aggregation tables the similar feature previously available in the deprecated static aggregation tables.

Consider the following author-time aggregation table definition:

<data-table  id="NewAggRemapKeys">
  <fields>
    <field ignore-case="true" type="string" name="RemappedString1"/>
    <field type="bool" name="bool1" />
    <field ignore-case="true" type="string" name="string2"/>
    <field type="long" name="SumCount"/>
    <field type="int" name="GroupCount"/>
  </fields>
  <primary-key>
    <field ref="RemappedString1"/>
    <field ref="bool1"/>
  </primary-key>
  <data-sources>
    <data-source>
      <aggregation table-ref="AllTypesSnapConcurrency4">
        <query>
          <projection>
            string1 as RemappedString1, bool1,
            sum(Count) as SumCount,
            lastval(string2) as string2, 
            count() as GroupCount,
          </projection>
        </query>
      </aggregation>
    </data-source>
  </data-sources>
</data-table>

Notice that the table defines the field RemappedString1, which field is also one of the fields in the Primary Key. This field does not appear in the base table, but the query includes string1 as RemappedString1 as part of the projection, and string1 DOES appear in the base table. The system will now correctly construct the group-by portion of the query to include string1 instead of RemappedString1.

LiveView Desktop previously supported adding newlines to format queries in the Query Edit field only when content was pasted into the Query Edit field. This release adds support for using Shift-Enter to format queries with newlines while editing a query.

The string that the LiveView JavaScript API returns for a timestamp field was updated to conform to the format required by the ECMA Specification. In particular, the API was returning date and time strings separated by a space, but are now separated with an uppercase T.

The user-defined Transform interface was changed in LiveView 2.0.1 to include the "Old" tuple values associated with an event. The transform interface's DataIn schema now has an additional field name name Old, which is of type tuple and has the same schema as the new tuple fields.

To upgrade, you must regenerate the interface files for your transform applications and change the DataIn schema of your existing transform applications to match the new SourceTableNameTransformOut named schema. Use either the new StreamBase → Generate LiveView Interfaces menu described below, or the lv-server generate command to regenerate your interface files.

When LiveView Server is started, it launches a Jetty service that hosts the new JavaScript API as well as a default web app accessible on http://hostname/lv-web. For LiveView 2.0.1, this web application was restyled and updated to take advantage of the new JavaScript API, and now has new functionality added. The three parts of the lv-web application are:

Author-time aggregation table configuration now allows multiple <projection></projection> and <predicate></predicate> elements. This allows multiple <?xinclude> statements to be used to build up the projection and predicate expressions.

A new menu option provides the ability to generate StreamBase interfaces as well as schemas for all defined extensions in a LiveView project, such as EventFlow modules that provide a Data Source, Publisher, Preprocessor, or Transform for a LiveView data table. Select any LiveView project in the Package Explorer view, right-click, and select StreamBase → Generate LiveView Interfaces. The previously existing StreamBase → Generate LiveView Schemas menu option generates or re-generates only the schemas for all LiveView data tables in the project. See Generating Interfaces for further information.

The lvserver generate command now has an --all option that serves the same function on the command line, to generate all interface files needed by the specified LiveView project.

When creating an alert rule in LiveView Desktop, you can now specify the use of one of the LiveView aggregate functions. The Aggregate Condition field in the Alert Rule configuration dialog should be an expression that evaluates to a boolean value, such as sum(Volume) > 1000. The Advanced Alerting sample was updated to demonstrate this new feature.

When a query reaches a limit specified in the query with --limit, LiveView Desktop now reports the limit reached condition with a yellow tip bar at the top of table views, or change in the description bar for chart views. In previous releases, Desktop reported limit reached conditions with a an error dialog.

Workspace-related permission checking was enhanced in two dimensions:

LiveView Desktop charting was upgraded to use the DataWatch (formerly Panopticon) library version 12.4.3.

All LiveView adapters (Query, Publish, Ready, and Delete) in the same container now share a LiveView Server connection by default. Previously, each adapter had its own independent LiveView connection. If you need an individual adapter to have its own connection, clear the Share LiveView Connection check box in the Properties view that adapter instance.

The LiveView Publish adapter now has a configurable delete field. Leaving this field blank disallows deletions from that adapter instance.

The Publish adapter also has a new passthrough that passes the input tuple to its output without change.

The .NET version of the LiveView Client API was updated to support the high availability feature called Multiconnect capability that was added to the Java Client API in LiveView 2.0.0. With this feature, clients can specify multiple LiveView Server URIs and configure how these connections should be handled. The .NET Client API also now supports the new getSendTupleInfo and sendTupleAction APIs.

The LiveView Java Client API sample was updated with a new sample, MultiConnect.java, that illustrates that new feature.

Two log appenders are now available in the LiveViewClient package:

The first is an SLF4J logback appender and the second is a Log4j appender. These appenders can be configured to send log events from any Java program using either Logback or Log4j to a LiveView Table.

The LiveView Java Client API now has a getIndices method to return a list of the indexed fields for a LiveView table.

The LiveView Java Client API now has checkPermission and checkPermissions methods to determine whether the current authenticated user is entitled to perform a requested action.

The standalone Help Viewer on Windows and the sbhelp utility on Linux and OS X were removed from the StreamBase distribution. The move to Eclipse 4.4 as a base for StreamBase Studio caused complications that were solved for Studio, but could not be resolved for the Help Viewer. Instead, use the the help system invokable from StreamBase Studio's Help → Help Contents menu, which provides the identical content as the standalone Help Viewer. You can also see the Eclipse Help format documentation on docs.streambase.com, and the website format documentation locally installed as part of Studio, or on docs.tibco.com. See Using the Help System for details.

The LiveView System Tables Page in the LiveView Administration Guide was extended and updated to match current versions of the system tables.

The EventFlow Applications for LiveView page of the LiveView Development Guide has a new section, Generating Interfaces, on the requirement to use StreamBase interface files when adding EventFlow modules to a LiveView project, and describes three ways to generate the interfaces. The lv-server reference page was reworked to expand and clarify the generate subcommand for generating interfaces.

A new first section of the LiveView Server System Configuration page discusses project-specific configuration files.

TIBCO Live Datamart 2.0.x is now automatically installed as part of TIBCO® StreamBase 7.5.x. As before, TIBCO Live Datamart is separately licensed. However, you no longer need to download and run a separate installer to access Live Datamart features.

Starting with this release, TIBCO LiveView Desktop has its own installation instruction page, independent of the base kit's instructions. See Installing LiveView Desktop.

On Windows and Linux, TIBCO LiveView Desktop 2.0.x installs a private copy of an Oracle Java JRE, release 1.7.0_u71, under the liveview home directory, and always runs with that JRE. This is true whether LiveView Desktop is installed on a machine with no other StreamBase software, or is installed under STREAMBASE_HOME/liveview. On these platforms, LiveView Desktop's JRE is independent of the TIBCO StreamBase JDK, if present.

However, on Macintosh OS X, LiveView Desktop requires Apple Java 1.6.x, which you must install separately from the Desktop installation. Apple Java is no longer included in OS X by default, and it is automatically uninstalled when you upgrade from one OS X version to the next. You must download and install the latest Apple Java from Apple's Support site.

You can have a version of Oracle Java 7 installed on OS X alongside Apple Java 6. LiveView Desktop looks only for Java 6, and fails to start if not found.

This release of StreamBase Studio introduces a new forms-based visual editor for LiveView configuration files, called lvconf files. The visual editor reads and stores the same XML format as before, but greatly improves and accelerates your ability to create and maintain lvconf files without constant reference to the XSD specification. Each lvconf type has its own form; when creating a new lvconf file, you specify the lvconf type, which determines the form to use.

Every field has pop-up help text when you hover the pointer in or over each field. This is the same help text found in the lvconf XSD specification.

The valid features for each lvconf type are organized into tabs along the bottom of the visual editor window. The last tab for each form provides a Source view, which allows you to view and edit the underlying XML file you are editing. Edits made in the Source view are immediately reflected on other tabs, and vice versa. However, the Source view is not itself a validating XML editor, but relies on the various forms tabs to validate the lvconf file being edited.

The menu selection to create a new lvconf file was rebranded. Use File → New → TIBCO LiveView Configuration File to create a new lvconf file. The visual editor is now the default editor for new and existing lvconf files.

The new visual lvconf editor does not support Xincluded files and certain other advanced features of lvconf files. In particular, if any lvconf file in your existing projects includes XML comments in <!-- --> blocks, such comments are not preserved when the lvconf file is opened and saved in the visual editor.

For features not supported by the visual lvconf edtor, the text-based validating XML editor is still available. Other than Xincludes and comments, any feature valid in the XML of an lvconf file that is entered with the text-based XML editor is preserved on re-opening the file in the visual editor. You can also edit advanced features using the Source tab of the visual editor.

To access the validating text-based XML editor directly, select an lvconf file in the Package Explorer view, right-click, and select Open With → LiveView Confguration XML Editor.

LiveView 2.0 made internal changes to the way ad-hoc aggregation queries from LiveView clients are calculated. Higher performance is achieved by compiling more optimized code and sharing internal state in the form of generated data classes. No change is necessary for existing aggregation queries to take advantage of the new performance; they will automatically be faster and take fewer resources when run against LiveView 2.0 Servers. This higher performance approach is also used for the new author-time aggregation tables described next.

This release introduces a new way to provide LiveView data tables with the aggregated results of data published to another LiveView table. We are naming the new feature author-time aggregation, because its aggregate and predicate expressions are written in a table's lvconf file and cannot be changed once the LiveView Server is running. The LiveView table with the aggregate results is called the aggregate table, while the LiveView table used as a source is called the base table.

One of the advantages of author-time aggregation is that it uses the same projections you use in dynamic aggregation, and in the projection portion of queries entered into LiveView Desktop or lv-client. This allows you to develop a projection using ad hoc queries in Desktop or lv-client, and then copy the tested, working projection to the visual lvconf editor to create an author-time aggregation table.

Another advantage of author-time aggregation over static aggregation is that you can now specify time-based predicates such as when ArrivalTime between now()-minutes(10) and now(), and thus aggregate over a time period. This was not possible with static aggregation.

To specify an author-time aggregation table as a data source for a LiveView data table, use File → New → TIBCO LiveView Configuration File to create a new Data Table. Then, use the Data Sources tab in the visual editor, and select the Aggregation check box. In the Table Reference field, specify the name on an existing LiveView base data table already configured in the current project, then specify the Projection and Predicate portions of a LiveQL query that will select from the specified base table and emit a stream of aggregated results.

The static aggregation feature of previous releases that uses a selection of static aggregation functions, is superseded by the new author-time aggregation described in the previous item. Static aggregation is still supported by LiveView Server and all existing static aggregations continue to work as before. However, because author-time aggregation offers comparable functionality with immensely more flexibility, the former static aggregation feature is now deprecated and is expected to be removed in a future release. Consider migrating your LiveView projects to use author-time aggregation.

This release adds the following LiveView aggregate functions that can be used in the projections of both ad hoc LiveQL queries and author-time aggregate tables:

The first six functions are the slope() family of related aggregate functions already existing in the StreamBase expression language, but newly available for LiveView aggregation.

The aggregate version of the unique() function was newly added to the StreamBase expression language in this release, primarily for use in LiveView aggregations. unique() returns a list, and LiveView columns cannot currently be sourced from a list. Thus, to use unique() as part of an author-time aggregation projection, you must wrap unique() with joinlist(), as in the following example usable with the Hello LiveView sample. joinlist() is an alias newly added in this release for both simple and aggregate versions of the join() function. It is used in author-time aggregation projections in its aggregate form.

select joinlist(",", unique(Severity, 5)) as SeverityList from LVAlerts

When starting LiveView Server, the ready to accept message on the console is now bracketed by blank lines to make it easier to find in a long log history. If you have custom log-parsing code that looks for the ready to accept message, you may need to adjust that code for the new format of the message:

...
timestamp INFO  LVInfoQuery - { 'ItemsSales'::SnapQueryMarker }(tupleid=0 ...
timestamp INFO { Server Started } -

*** All tables have been loaded. LiveView is ready to accept client connections. *** 

timestamp INFO  LVInfoQuery - { 'ItemsSales'::Original Query }"{""CQSConnectionID"": ...
...

The lv-client and lv-server commands are now installed in STREAMBASE_HOME/bin, and are thus always on the PATH when you open a StreamBase Command Prompt on Windows, or when you use an OS X, Linux, or Solaris terminal configured with sb-config --env. There is no longer a need to prefix these command names with liveview\tools to run them.

Reference pages for these commands are now found in the StreamBase Command Reference, with links to the same pages in the former LiveView Command Reference. On the well-configured OS X, Linux, or Solaris systems, man lv-client and man lv-server show syntax references at the shell prompt.

This release includes an entirely new JavaScript Client API. The new API focuses on simplicity, conformity to common JavaScript patterns, compatibility with modern JavaScript frameworks, and detailed documentation. Many of the extraneous features included with the old API were removed in an effort to allow API users to take more control and have more freedom to manipulate and display LiveView data in a way that best suits their needs.

The new JavaScript Client API supersedes and replaces the first-generation JavaScript API. The first-generation API is no longer supported by the current LiveView Server, and customers must migrate any existing web-based LiveView client applications to the new API in order to run them on LiveView 2.0.x servers. Full JavaScript Client API Documentation is incorporated into the LiveView documentation set, as well as an introduction to using the API.

The LiveView Java Client API in previous releases had an undocumented API to manage LiveView Alerts that was not exposed to customers. That API is still not exposed, but is nonetheless now deprecated. Replacing it is a new, cleaner public API whose starting point is LiveViewConnection.getAlertManager(), which returns an instance of com.streambase.liveview.client.alert.AlertManager. This offers a set of operations and classes for creating, deleting, and interrogating the server about the Alerts it has.

The Java Client API now also supports automatic failover and reconnection to members of a cluster of LiveView servers. This release introduces a new multi-connection configuration object, MultiConnectionConfig, with which clients can connect and re-connect to one of several LiveView Servers in a high availability cluster configuration.

Finally, there are two new methods that allow clients to trigger actions on the server. Look in the JavaDoc for getSendTupleInfo and sendTupleAction.

These features are documented in the LiveView Java Client API Javadoc, which is now combined with classes from the StreamBase Client API to make a single Javadoc set with interdependent cross-reference links to each API's features.

TIBCO LiveView Desktop versions can connect to various LiveView server versions as shown in the following table:

In all cases, LiveView Desktop is restricted to the capabilities of the connected server. That is, each Desktop version can connect to and display results that are consistent with the capabilities of each server release.

Client applications built with the LiveView Client API, including lv-client and any custom applications you have built, are compatible with LiveView Server versions as shown in the following table:

In TIBCO LiveView releases 1.6.x and 2.0.x, in the DataIn input stream used for populating a data table, the internal use of the field CQSDataUpdatePredicate is now deprecated. Always set this field to null when sending tuples to the DataIn input port.

Starting with TIBCO LiveView 1.6.0, the DataIn input stream has a boolean field named CQSDelete that, when set to true, deletes any row with exactly matching primary key fields. If you have existing generated transform, preprocessor, or publisher EventFlow applications from a pre-1.6.0 release, use the interface generator to update your application schemas. See the lv-server reference page for information on using the interface generator.

The SB Demo perspective in StreamBase Studio now includes a demonstration of LiveView that shows LiveView Desktop connecting to a recorded simulation of the stream emitted by Wikipedia that records each edit made to each page of the English Wikipedia. Instructions are provided to convert the demo to use live data from Wikipdeia.

The new JavaScript Client API is illustrated in the Creating web applications with JavaScript sample shipped with LiveView. Load this sample in StreamBase Studio and follow the instructions in its README.txt file.

The README.txt files for most LiveView samples were edited for clarity and to show current command lines for invoking the lv-client and lv-server commands.

The home page for the LiveView documentation set was reorganized using the same ordering used on the StreamBase home page. The order of rows reading down the home page's table now mirrors the order of the navigation menu across the top of the non-Eclipse format of the set. Text on the home page was edited for clarity.

As reported on the TIBCO StreamBase 7.5.0 New and Noteworthy page, the LiveView and StreamBase documentation sets were combined such that it is easy to switch back and forth between them. The combining of the doc sets has the following features reported on the StreamBase 7.5.0 page:

Many pages in the LiveView documentation set were renamed, reorganized, and rewritten. Please bear with us as this undertaking continues over the next few releases. In particular, see: