Cluster Monitor Application

The Cluster Monitor application is a ready-to-run and configurable StreamBase Application that monitors the performance of clusters and nodes in a StreamBase Runtime fabric. The application consists of a StreamBase monitoring EventFlow fragment and a LiveView server fragment. The application:

Using the default configuration, the LiveView server automatically enables LiveView Web as the client to display cluster monitoring data.

Once the Cluster Monitor node is started and the Cluster Monitor application is running, open a browser to view cluster data in LiveView Web for your running application nodes.

Enter: http://localhost:11080/lvweb. The Cluster Monitor application uses 11080 as its default LiveView Web port, to avoid conflicts with the standard LiveView Web port, 10080.

LiveView Web displays cluster statistics using the following set of LiveView Web cards:

The following monitoring behavior parameters are configurable:

You can change the Cluster Monitor application's configuration:

After activating a new configuration, restart the Cluster Monitor application with the following command:

epadmin --servicename=MONITOR_NODE_NAME restart container --engine=cluster-monitor

The Cluster Monitor configures the following statistics tables by default:

Services Table: The monitor always contains a Services table showing services that have been discovered and their current state.

StreamBaseInfo Table: EventFlow/LiveView server Java heap memory use, and aggregate total number of queued tuples.

NodeInfo Table: Per node shared memory usage, transaction rate, and deadlock counter, and CPU usage for the machine where the node is running.

epadmin --servicename=monitor.monitorCluster display history --seconds=1

The Cluster Monitor application attempts to connect to each discovered service, authenticating each using the configured credentials. The epadmin commands use the administrationAuthentication section of the ClusterMonitor configuration file, as shown in StreamBase Cluster Monitor Configuration. By default, no credentials are configured. The application is only able to monitor services running on the local node, started by the same user who installed the Cluster Monitor.

The configuration supports a single set of credentials for epadmin commands, and a single set of credentials for EventFlow and LiveView services. For simplicity, TIBCO recommends configuring a common login credential throughout the target cluster.

To configure EventFlow and LiveView services information, use the EventFlow section of the ClusterMonitor configuration.

For reference, the following shows the properties of the configuration file that is supplied with the Cluster Monitor application.

//
// Default configuration for the StreamBase Cluster Monitor.
//
// To change this configuration, make a copy of this entire file
// and use the nodedeploy option to epadmin install node.
//
// HOCON substitution variables used in this configuration:
//
//      NODE_NAME       Required. The name of the node that the monitor application is
//                      installed to (the nodename parameter to epadmin install node).
//
//      LIVEVIEW_PORT   Defaults to 11080
//
// These variables may be overridden via the substitutions or substitutionfile
// parameters to epadmin install node.
//
name = "ClusterMonitor"
version = "1.0"
type = "com.tibco.ep.dtm.configuration.node"
configuration =
{
  NodeDeploy =
  {
    nodes  =
    {
      // A default node name such as "cluster" shown here is required for this
      // configuration to validate in the Configuration Editor in Studio.
      "${NODE_NAME:-cluster}" =
      {
        description = "Node for running the ClusterMonitor"

        engines =
        {
          "cluster-monitor" =
          {
            fragmentIdentifier = "com.tibco.ep.cluster.eventflow"

            configuration =
            [
              """
              name = "cluster-monitor-service-discovery"
              version = "1.0.0"
              type = "com.tibco.ep.streambase.configuration.servicediscoveryadapter"
              configuration =
              {
                ServiceDiscovery =
                {
                  associatedWithEngines = [ "cluster-monitor" ]
                  // Service names that will be discovered by the cluster monitor.
                  // Optional. Defaults to all service names found.
                  // Uncomment to restrict.
                  // serviceNames = [ "cluster1", "cluster2", "nodeA.cluster3" ]

                  // Service types that will be discovered by cluster monitor.
                  // Optional. Empty defaults to all service types, but the cluster
                  // monitor only knows how to monitor node, eventflow and
                  // liveview services.
                  serviceTypes = [ "node", "eventflow", "liveview" ]

                  // The number of seconds between discovery requests.
                  // Optional. Defaults to 1.
                  // discoveryBrowseIntervalSeconds = 1

                  // This causes the cluster-monitor event flow application
                  // to wait for the LiveView server to become ready before
                  // starting.  Do not change.
                  autostart = false

                  // Whether or not services running within the monitor's node
                  // are discovered and monitored. Defaults to false.
                  includeLocalServices = ${INCLUDE_LOCAL_SERVICES:-false}
                } // end of ServiceDiscovery object
              }
              """,

              """
              name = "clustermonitor"
              version = "1.0.0"
              type = "com.tibco.ep.streambase.configuration.clustermonitor"
              configuration =
              {
                ClusterMonitor =
                {
                  associatedWithEngines = [ "cluster-monitor" ]

                  // A list of administration commands to run against discovered
                  // node services, every collection interval, and then publish
                  // to LiveView server tables.
                  commands =
                  [
                    {
                      // Administration command name. Required.
                      commandName = "display"

                      // Administration target name. Required.
                      targetName = "history"

                      // A list of command parameters. Optional.
                      parameters =
                      {
                        "seconds" = "1"
                      }

                      // The name of the LiveView table for the command results.
                      // This name must be a legal LiveView table name, starting
                      // with a letter, followed by a combination of letters, digitis,
                      // and underscores.  Whitespace is not allowed.
                      // Optional. Defaults to "t_commandName_targetName"
                      tableName = "NodeInfo"

                      // Number of seconds between command invocations.
                      // Optional. Defaults to 1.
                      collectionIntervalSeconds = 1
                    },

                    // Additional commands can be added here.
                  ]

                  // Age limit for data rows in the monitor tables.
                  // Optional.  Defaults to 60.
                  // rowAgeLimitSeconds = 60

                  // The interval at which tables are checked for removing old rows.
                  // Optional.  Defaults to 30.
                  // rowCheckIntervalSeconds = 30

                  // Optional credentials for running the administration commands.
                  // administrationAuthentication =
                  // {
                      //    // The user name to use when connecting to the node.
                      //    //
                      //    userName = "administrator"
                      //    //
                      //    // The password to use when connecting to the node.
                      //    //
                      //    password = "This is a plain text password"
                  // }

                  // Optional credentials for collecting StreamBase statistics.
                      //
                      // eventFlowAuthentication =
                      // {
                      //    //
                      //    // The user name to use when connecting to the
                      //    // EventFlow or LiveView StreamBase listener.
                      //    //
                      //    userName = "sbAministrator"
                      //    //
                      //    // The password to use when connecting to the
                      //    // EventFlow or LiveView StreamBase listener.
                      //    // A value beginning with '#!' is enciphered
                      //    // with the sbcipher tool.
                      //    //
                      //    password = "#!xyzzy"
                      // }
                        
                   } // end of ClusterMonitor
                 } // end of configuration for c.t.e.streambase.configuration.clustermonitor
               """,

               """
               name = "cluster-monitor-operator-parameters"
               version = "1.0.0"
               type = "com.tibco.ep.streambase.configuration.sbengine"
               configuration =
               {
                 StreamBaseEngine =
                 {
                   streamBase =
                   {
                     operatorParameters =
                     {
                        LIVEVIEW_PORT = ""${LIVEVIEW_PORT:-11080}
                     }
                   }
                 }
               }
               """
             ]
           } // end of cluster-monitor engine configuration set

           "liveview-server" =
           {
             fragmentIdentifier = "com.tibco.ep.cluster.liveview-server"

             configuration =
             [
               """
               name = "liveview-server-listener"
               type = "com.tibco.ep.ldm.configuration.ldmclientapilistener"
               version = "1.0.0"
               configuration =
               {
                 ClientAPIListener =
                   {
                     associatedWithEngines = [ "liveview-server" ]
                     portNumber = ${LIVEVIEW_PORT:-11080}
                   }
                 }
               """,

               """
               name = "liveview-sb-listener"
               type = "com.tibco.ep.streambase.configuration.sbclientapilistener"
               version = "1.0.0"
               configuration =
               {
                 ClientAPIListener =
                 {
                   associatedWithEngines = [ "liveview-server" ]
                   apiListenerAddress =
                   {
                     portNumber = 0
                   }
                 }
               } // end of c.t.e.streambase.configuration.sbclientapilistener
               """,

               """
               name = "liveview-server-engine"
               version = "1.0.0"
               type = "com.tibco.ep.ldm.configuration.ldmengine"
               configuration = 
               {
                 LDMEngine = {
                   jvmArgs =
                   [
                     "-Xmx4g"
                     "-Xms1g"
                     "-XX:+UseG1GC"
                     "-XX:MaxGCPauseMillis=500"
                     "-XX:ConcGCThreads=1"
                   ]
                   ldm = { }
                 }
               } // end of com.tibco.ep.ldm.configuration.ldmengine
               """
             ] 
          } // end of liveview-server engine configuration set
        } // end of engines
      } // end of NODE_NAME settings
    } // end of nodes
  } // end of NodeDeploy
} // end of top-level configuration