MarketsIO

Overview Copied

The MarketsIO plugin is a Collection Agent plugin that monitors MarketsIO entities by reading from its shared memory.

Prerequisite Copied

The MarketsIO plugin should be run on the machine running MarketsIO.

Geneos environment Copied

This plugin requires the following versions of Geneos components:

The MarketsIO plugin jar file is packaged with Netprobe, and is stored in the collection_agent folder. Alternatively, you can download separate binaries for the MarketsIO plugin from ITRS Downloads.

Configure Geneos to deploy the MarketsIO plugin Copied

The MarketsIO plugin supports Collection Agent publication into Geneos using dynamic Managed Entities. To setup the plugin in Geneos:

  1. Set up your Collection Agent plugin.
  2. Configure your mappings in Dynamic Entities > Mapping.
  3. Configure your other Dynamic Entities in the Gateway.

Set up your Collection Agent plugin Copied

  1. Set up your collector in the Gateway Setup Editor by defining a collector in Dynamic Entities > Collectors. For more information, see Collectors in Dynamic Entities.
  2. In the collector’s plugin configuration, select MarketsIO.
  3. In the MarketsIO Collector field, input your desired MarketsIO configuration. Refer to configuration reference.

Configure your mappings Copied

Select one of the options listed below to configure your dynamic mappings.

For more information, see the Mapping and mapping group in Dynamic Entities documentation.

Configure your other Dynamic Entities in the Gateway Copied

See Create Dynamic Entities in Collection Agent setup for a more detailed procedure.

Note

A MarketsIO collector configuration template is also available and can be added to your Gateway setup. This template contains a set of configuration to monitor different aspects of the MarketsIO EventStream component. Refer to Gateway setup template for MarketsIO EventStream monitoring.

Configuration reference Copied

Below is an example YAML file which may require some changes for your project’s configuration:

collectors:
- name: marketsio
  type: plugin
  className: MarketsIOCollector

  # (Mandatory) Shared memory key name to monitor
  sharedmemInstance: <shared memory instance name>

  # (Mandatory) A unique string to identify the instance this collector is monitoring. 
  # This will be used as a dimension in the datapoints, to define the entity emitting the data.
  monitoredInstanceName: <string identifier>

  # Data groups is a set of data that you want to monitor.
  # For example, one group for connection-related monitoring, another group for server-related monitoring
  dataGroups:
  # (Mandatory) Unique Name of the data group
  - name: "EventStream Info"

    # A data group can be a collection of data from multiple entities.
    # An entity, in MarketsIO data, represents one set of data from a class which defines class, instance, and variables.
    # Each entity can be a table record or a key-value record.
    entities:

    # An entity configuration defines the following.
    # (Mandatory) instance: The instance id of the entity. It is in the form <instance>.<child-instance>.<child-instance>...
    # Should be defined as a regex if isTableRecord config is set to true.
    - instance: EventStream

      # (Mandatory) className: the name of the class of the entity to be monitored, with the given instance id.
      className: EventStream

      # (Optional) isTableRecord defines how this entity configuration is processed.
      # If this is true, the entity defined by this configuration is treated as a table record.
      # This means that the instance id defined is a regex that may match multiple entities.
      # This entity is similar to table record in the RMC Plugin.
      isTableRecord: <true/false>

      # The following configuration will define the datapoints that will be published for this entity.
      # What are datapoints: https://docs.itrsgroup.com/docs/obcerv/platform/current/getting-started/architecture/index.html#datapoints
      # In summary, a datapoint is a single piece of observable data. Some examples of datapoints are CPU usage, memory usage, and disk space.
      # The following are the relevant parts of the datapoint that you need to know to configure the datapoint in the config.
      # - name (mandatory) - Unique identifier of the datapoint
      # - value (mandatory) - The value of the data
      # - dimensions (optional) - Dimensions are key-value pairs that identify the resource emitting the data. For example, for CPU usage, its dimension would be the machine name.

      # List of variables to publish as datapoints
      variables:
      # (Mandatory) Name of the MarketsIO variable where data is obtained from
      # MarketsIO variables with type ByteBuffer are not supported.
      - variable: Name

        # (Optional) Alias will be used as the name of the datapoint. If not specified, the variable name will be used.
        alias: "EventStream Name"

        # (Optional) Values can be: Dimension, Gauge, EntityAttribute, Counter, StatusMetric.
        # If not specified, the data type is derived from the type from MarketsIO.
        # If MarketsIO type is numeric, it will be published as a Gauge. If boolean or string, it will be published as StatusMetric.
        dataType: EntityAttribute

        # (Optional) The unit of the variable, if defined as a Gauge or Counter.
        # Format is the Unit description in Obcerv platform. If not specified, none will be used.
        # unit: "per second"

        # (Optional) You can define more than 1 variable
      - variable: Version
        # alias: <name>
        dataType: EntityAttribute
        # unit: "per second"

      children:
      # (Mandatory) The instance suffix of the children entities that will be appended to the parent instance id
      # If full instance ID is Parent.First-Child.Second-Child and Parent is the instance of this parent entity,
      # the instance-suffix will be First-Child.Second-Child.
      - instanceSuffix: MainContext
        # (Mandatory) className of this child entity
        className: AxisContext
        # List of variables of the child entity. Same configuration options as variables in the parent entity.
        variables:
        - variable: Channels
          dataType: Counter

        # (Optional) You can define more than one child entity.
      - instanceSuffix: MainContext.Dispatcher
        className: DispatcherMonitor

        # List of variables of the child entity
        variables:
        - variable: Type
          dataType: EntityAttribute

      # Only valid if isTableRecord is true
      # Elements from the instance id string that can be captured by regex with capture group.
      # The descriptions below will use this example:
      # instance regex "EventStream\\.MainContext\\.Control\\.([^.]+)$"
      # which will match
      # - EventStream.MainContext.Control.Dacs:SYDNEY
      # - EventStream.MainContext.Control.Dacs:DEV
      # - EventStream.MainContext.Control.Dacs:HK
      keyElements:
      # The number of the capture group to get data from.
      # In the example above, captureGroup 1 will match "Dacs:SYDNEY", "Dacs:DEV", "Dacs:HK"
      # This can be used as a dimension for the datapoints LoginsRejected, LoginsAccepted, and LoginsTotal, etc.
      - captureGroupNum: <number>
        # (Mandatory for captureGroupNum) This defines the name of the datapoint or dimensions.
        alias: <name>
        # (Optional) Default is EntityAttribute.
        dataType: <type>

      # Name of the capture group specified in the regex to use as data.
      # If regex is: "EventStream\\.MainContext\\.Control\\.(?<domain>[^.]+)$",
      # then captureGroupName should be domain to get "Dacs:SYDNEY", "Dacs:DEV", "Dacs:HK".
      - captureGroupName: <name>
        # (Optional) Name to use as name of the datapoint/dimension. If not specified, the capture group name will be used.
        alias: <name>
        dataType: <type>

Sample configuration and dataview Copied

Below is a sample MarketsIO collector configuration which monitors the MarketsIO Access Point Engines:

monitoredInstanceName: MIO-EventStream-1
sharedmemInstance: EventStream-1

dataGroups:
- name: APEngine
  entities:
  - className: "APEngine"
    instance: "EventStream\\.AccessPoint\\.(?<engineName>[^.]+)"
    isTableRecord: true
    keyElements:
    - captureGroupName: engineName
      alias: engine
      dataType: Dimension
    variables:
    - variable: Channels
      dataType: Counter
    - variable: Users
      dataType: Counter
    - variable: OpenMsgs
      dataType: Counter
    - variable: SnapOpenMsgs
      dataType: Counter
    - variable: CloseMsgs
      dataType: Counter
    - variable: RefreshMsgs
      dataType: Counter
    - variable: StatusMsgs
      dataType: Counter
    - variable: UpdateMsgs
      dataType: Counter
    - variable: UpdateRate
      dataType: Gauge
      unit: "per second"
    - variable: PeakOpenRate
      dataType: Gauge
      unit: "per second"
    - variable: PeakCloseRate
      dataType: Gauge
      unit: "per second"
    - variable: PeakRefreshRate
      dataType: Gauge
      unit: "per second"
    - variable: PeakUpdateRate
      dataType: Gauge
      unit: "per second"
    - variable: ViewTableSize
      dataType: Gauge
      unit: "per second"

This configuration will display the following dataview:

MarketsIO sample dataview

Using the built-in mapping, the monitoredInstanceName becomes the name of the entity and the name of the dataGroup becomes the name of the sampler.

Gateway setup template for MarketsIO EventStream monitoring Copied

A MarketsIO Collector configuration template file is packaged with the Gateway. This template contains a set of configuration to monitor different aspects of the MarketsIO EventStream component.

The template file is located in <gateway package>/templates/marketsio_collector_config.xml. To use the template, follow these steps:

  1. Open the Gateway Setup Editor.

  2. In the Gateway Setup Editor, right-click on the Includes folder and select New Include.

  3. Change the Priority to the desired priority of the include file.

  4. In the Location field, enter the path of the include file (for example, <gateway package>/templates/marketsio_collector_config.xml).

  5. Load the file. Go to Environments > MarketsIOEnv and set the correct values for mioSharedMemKey and mioMonitoredInstanceName. These are the variables used in Dynamic Entities > Collectors > MarketsIO-EventStream collector configuration.

    • mioSharedMemKey — corresponds to the sharedmemInstance configuration. This must be set to the name of the shared memory instance that will be monitored.
    • mioMonitoredInstanceName — corresponds to a string that will be used as the entity name in the Active Console. This must be set to a unique string that describes the instance you are monitoring.

  6. On the Probe configuration, add the MarketsIOMappingType to Probe > Dynamic Entities > Mapping Type. Refer to Collection Agent setup for more information on adding a mapping type to the Probe.

  7. Start the Probe. After Probe and plugin initialization, a managed entity with the name defined in mioMonitoredInstanceName will appear in the Active Console. Under this entity should be a set of dataviews, as shown in the sample dataview.

MarketsIO Collector Template Copied

The template file consists of the following:

Supported platforms Copied

Since MarketsIO only supports RHEL 7 and RHEL 8, the MarketsIO plugin will also only support these versions.

["Geneos"] ["User Guide"]

Was this topic helpful?