---
title: Broadcom WatchTower z/IRIS
description: >-
  Monitor your mainframe with logs, metrics, and traces from WatchTower z/IRIS
  in Datadog
breadcrumbs: Docs > Integrations > Broadcom WatchTower z/IRIS
---

# Broadcom WatchTower z/IRIS
Supported OS Integration version1.0.0
{% callout %}
# Important note for users on the following Datadog sites: us2.ddog-gov.com

{% alert level="info" %}
To find out if this integration is available in your organization, see your [Datadog Integrations](https://app.datadoghq.com/integrations) page or ask your organization administrator.

To initiate an exception request to enable this integration for your organization, email [support@ddog-gov.com](mailto:support@ddog-gov.com).
{% /alert %}

{% /callout %}
        Watch z/IRIS streams mainframe OpenTelemetry signals to Datadog.OOTB WatchTower Dashboards to visualize the health of z/OS systems.OOTB WatchTower CPU Monitor to increase mainframe system reliability.Embedded error and exception documentation for faster MTTR.
## Overview{% #overview %}

Broadcom's WatchTower platform provides a comprehensive picture of mainframe health and performance. With its integrated real-time information streaming (z/IRIS), teams can anticipate failures based on past patterns, prevent small issues from becoming outages, and proactively manage z/OS operations.

This WatchTower z/IRIS integration collects metrics, logs, and traces via OpenTelemetry, and includes out-of-the-box content for seamless observability in Datadog:

- Monitor z/OS systems and applications using WatchTower's curated and customizable dashboards.
- Enable alerts on resource contention and application anomalies with WatchTower's recommended mainframe monitors.
- Enrich mainframe logs using the included log pipeline for easier analysis and correlation.

## Setup{% #setup %}

### Prerequisite{% #prerequisite %}

Verify that WatchTower z/IRIS is installed and running. Refer to the WatchTower z/IRIS Installation documentation on the [TechDocs Portal](https://techdocs.broadcom.com/) for more information about installing z/IRIS in your environment.

### Installation{% #installation %}

1. **Configure the OpenTelemetry Collector**

   - Configure the OTLP receiver

WatchTower z/IRIS can export telemetry over HTTP or gRPC. Refer to the z/IRIS IronTap configuration to verify the appropriate receiver is configured.

   - [Enable OTLP logs ingestion](https://docs.datadoghq.com/opentelemetry/setup/otlp_ingest_in_the_agent.md?tab=host#enabling-otlp-logs-ingestion)
   - Add a Transform Processor to set the source of OTLP logs from z/IRIS

   ```yaml
     transform/datadog: 
      log_statements:
        - context: log
          statements:
            # set resource attribute if the instrumentation_scope name matches
            - set(resource.attributes["datadog.log.source"], "ziris") where scope.name == "com.broadcom.ziris.irontap"
   ```

Add a transformation to prefix all metrics streamed from z/IRIS with `ziris.`:

   ```yaml
       metric_statements:
        - context: metric
          statements:
            # Concat "ziris" and the current metric name with a "." separator
            - set(name, Concat(["ziris", name], ".")) where scope.name == "com.broadcom.ziris.irontap"
   ```

1. [Configure the Datadog Exporter and Connector](https://docs.datadoghq.com/opentelemetry/setup/collector_exporter/install.md#2---configure-the-datadog-exporter-and-connector)

Follow Datadog's documentation to add the Datadog exporter to your collector configuration and provide your API key. Add the processors `transform/datadog` to the z/IRIS pipelines exporting signals to your Datadog tenant.

1. Launch the collector and verify in Datadog that the renamed metrics (`ziris.*`) are appearing in the [Metrics Explorer](https://app.datadoghq.com/metric/explorer) and verify that mainframe traces and spans are streaming.

1. In Datadog, open the WatchTower z/IRIS integration tile and click **Install**.

Dashboards will be cloned into your organization, and the monitors will be available on the [Monitor Templates](https://app.datadoghq.com/monitors/templates) page.

1. In Datadog, open Log explorer and verify that the z/IRIS custom group facets is available for filtering.

## Data Collected{% #data-collected %}

### Metrics{% #metrics %}

|  |
|  |
| **ziris.http.server.request.duration**(gauge)                                                                                                | The aggregated distribution of duration for HTTP server requests in z/OS Connect APIs*Shown as millisecond*                                                                                                                                                                                                           |
| **ziris.irontap.correlation.active\_correlations**(gauge)                                                                                    | Number of child/downstream correlation objects kept in memory until a matching parent/upstream part is found. The maximum number of active correlations is derived from the irontap.correlation.active-correlations configuration.*Shown as operation*                                                                |
| **ziris.irontap.correlation.CICS\_PERFORMANCE\_TO\_CICS\_EXCEPTION.available**(gauge)                                                        | Number of available correlations before the capacity is reached for correlating CICS perfromance records to CICS Exception records.*Shown as operation*                                                                                                                                                               |
| **ziris.irontap.correlation.CICS\_TO\_DB2.available**(gauge)                                                                                 | Number of available correlations before the capacity is reached for correlating CICS performance records to Db2 records.*Shown as operation*                                                                                                                                                                          |
| **ziris.irontap.correlation.CICS\_TO\_MQ.available**(gauge)                                                                                  | Number of available correlations before the capacity is reached for correlating CICS performance records to MQ records.*Shown as operation*                                                                                                                                                                           |
| **ziris.irontap.correlation.SDSF.available**(gauge)                                                                                          | Number of available correlations before the capacity is reached for correlating SMF Type 30 records*Shown as operation*                                                                                                                                                                                               |
| **ziris.irontap.correlation.SDSF.completed**(count)                                                                                          | Number of completed correlations for SMF 30 records. "Completed" means that the correlation was completed either successfully or unsuccessfully. If the correlation processing fails, it is by definition not completed, and the counter will not increment.*Shown as operation*                                      |
| **ziris.irontap.correlation.SDSF.started**(count)                                                                                            | Number of started correlations for SMF 30 correlations "Started" means that a child/downstream part of one (or more) use cases has been found, so z/IRIS IronTap tries to find a matching parent/upstream part. If a matching downstream part is found, both sides are correlated.*Shown as operation*                |
| **ziris.irontap.correlation.SDSF.succeeded**(count)                                                                                          | Number of successful correlations for SMF 30. "Successful" means that for a correlation, the upstream part and the downstream part were successfully identified and correlated.*Shown as operation*                                                                                                                   |
| **ziris.irontap.correlation.seen\_correlators**(count)                                                                                       | Number of (parent/upstream) correlators kept in memory to be matched with possible incoming (child/downstream) correlators. The maximum number of seen correlators is derived from the irontap.correlation.correlation-info-capacity configuration.*Shown as operation*                                               |
| **ziris.irontap.correlation.SMF201\_TO\_CICS.available**(gauge)                                                                              | Number of available correlations before the capacity is reached for correlating z/IRIS Type 210 records to CICS Performance records.*Shown as operation*                                                                                                                                                              |
| **ziris.irontap.correlation.started\_correlations**(count)                                                                                   | Same as "irontap.correlation.[use-case].started" but for all use cases combined.*Shown as operation*                                                                                                                                                                                                                  |
| **ziris.irontap.correlation.ZCON\_TO\_CICS.available**(gauge)                                                                                | Number of available correlations before the capacity is reached for correlating z/OS Connect records to CICS Performance records.*Shown as operation*                                                                                                                                                                 |
| **ziris.irontap.correlation.ZCON\_TO\_CICS.completed**(count)                                                                                | Number of completed correlations for z/OS Connect to CICS records. "Completed" means that the correlation was completed either successfully or unsuccessfully. If the correlation processing fails, it is by definition not completed, and the counter will not increment.*Shown as operation*                        |
| **ziris.irontap.correlation.ZCON\_TO\_CICS.started**(count)                                                                                  | Number of started correlations for z/OS COnnect to CICS correlations. "Started" means that a child/downstream part of one (or more) use cases has been found, so z/IRIS IronTap tries to find a matching parent/upstream part. If a matching downstream part is found, both sides are correlated.*Shown as operation* |
| **ziris.irontap.correlation.ZCON\_TO\_CICS.succeeded**(count)                                                                                | Number of successful correlations for z/OS Connect to CICS records. "Successful" means that for a correlation, the upstream part and the downstream part were successfully identified and correlated.*Shown as operation*                                                                                             |
| **ziris.irontap.correlation.ZCON\_TO\_DB2.available**(gauge)                                                                                 | Number of available correlations before the capacity is reached for correlating z/OS Connect records to Db2 records.*Shown as operation*                                                                                                                                                                              |
| **ziris.irontap.kafka.bytes.received**(count)                                                                                                | Number of Kafka (Smf) record bytes received by the z/IRIS IronTap Kafka Consumer*Shown as byte*                                                                                                                                                                                                                       |
| **ziris.irontap.kafka.records.received**(count)                                                                                              | Number of Kafka (Smf) records received by the z/IRIS IronTap Kafka Consumer*Shown as occurrence*                                                                                                                                                                                                                      |
| **ziris.irontap.metrics.exported.failed**(count)                                                                                             | Number of failed exported OpenTelemetry metric signals.*Shown as occurrence*                                                                                                                                                                                                                                          |
| **ziris.irontap.metrics.exported.success**(count)                                                                                            | Number of successfully exported OpenTelemetry metric signals.*Shown as occurrence*                                                                                                                                                                                                                                    |
| **ziris.irontap.metrics.timeseries**(gauge)                                                                                                  | Number of timeseries stored in memory.*Shown as occurrence*                                                                                                                                                                                                                                                           |
| **ziris.irontap.metrics.timeseries.count**(gauge)                                                                                            | Number of timeseries stored in memory.*Shown as occurrence*                                                                                                                                                                                                                                                           |
| **ziris.irontap.metrics.timeseries.out\_of\_bounds\_after**(gauge)                                                                           |
| Number of timeseries that are not recorded because the SMF record occured after the end of the specified time interval.*Shown as occurrence* |
| **ziris.irontap.metrics.timeseries.out\_of\_bounds\_before**(gauge)                                                                          | Number of timeseries that are not recorded because the SMF record occured before the start of the specified time interval.*Shown as occurrence*                                                                                                                                                                       |
| **ziris.irontap.metrics.timeseries.removed**(count)                                                                                          | The number of timeseries that were removed from memory because they are too old.*Shown as occurrence*                                                                                                                                                                                                                 |
| **ziris.irontap.smf.100**(count)                                                                                                             | Number of SMF type 100 records processed by z/IRIS IronTap per record type.*Shown as occurrence*                                                                                                                                                                                                                      |
| **ziris.irontap.smf.101**(count)                                                                                                             | Number of SMF type 101 records processed by z/IRIS IronTap per record type.*Shown as occurrence*                                                                                                                                                                                                                      |
| **ziris.irontap.smf.102**(count)                                                                                                             | Number of SMF type 102 records processed by z/IRIS IronTap per record type.*Shown as occurrence*                                                                                                                                                                                                                      |
| **ziris.irontap.smf.110**(count)                                                                                                             | Number of SMF type 110 records processed by z/IRIS IronTap per record type.*Shown as occurrence*                                                                                                                                                                                                                      |
| **ziris.irontap.smf.1159**(count)                                                                                                            | Number of SMF type 1159 records processed by z/IRIS IronTap per record type.*Shown as occurrence*                                                                                                                                                                                                                     |
| **ziris.irontap.smf.116**(count)                                                                                                             | Number of SMF type 116 records processed by z/IRIS IronTap per record type.*Shown as occurrence*                                                                                                                                                                                                                      |
| **ziris.irontap.smf.123**(count)                                                                                                             | Number of SMF type 123 records processed by z/IRIS IronTap per record type.*Shown as occurrence*                                                                                                                                                                                                                      |
| **ziris.irontap.smf.201**(count)                                                                                                             | Number of SMF records processed by z/IRIS IronTap per record type.*Shown as occurrence*                                                                                                                                                                                                                               |
| **ziris.irontap.smf.255**(count)                                                                                                             | Number of SMF type 255 records processed by z/IRIS IronTap per record type.*Shown as occurrence*                                                                                                                                                                                                                      |
| **ziris.irontap.smf.30**(count)                                                                                                              | Number of SMF type 30 records processed by z/IRIS IronTap per record type.*Shown as occurrence*                                                                                                                                                                                                                       |
| **ziris.irontap.smf.70**(count)                                                                                                              | Number of SMF type 70 records processed by z/IRIS IronTap per record type.*Shown as occurrence*                                                                                                                                                                                                                       |
| **ziris.irontap.smf.buffer.queue.size**(gauge)                                                                                               | Number of SMF records currently in the buffer queue*Shown as occurrence*                                                                                                                                                                                                                                              |
| **ziris.jvm.gc.duration**(gauge)                                                                                                             | Duration for JVM garbage collection actions on z/OS from JVMs that are monitored by SYSVIEW.*Shown as millisecond*                                                                                                                                                                                                    |
| **ziris.jvm.memory.committed\_after\_last\_gc**(gauge)                                                                                       | Measure of memory committed after last garbage collection from JVMs that are monitored by SYSVIEW.*Shown as byte*                                                                                                                                                                                                     |
| **ziris.jvm.memory.init**(gauge)                                                                                                             | Initial requested memory from JVMs that are monitored by SYSVIEW.*Shown as second*                                                                                                                                                                                                                                    |
| **ziris.jvm.memory.limit**(gauge)                                                                                                            | Measure of max obtainable memory from JVMs that are monitored by SYSVIEW.*Shown as byte*                                                                                                                                                                                                                              |
| **ziris.zos.connect.elapsed\_time**(gauge)                                                                                                   | The elapsed time for an incoming REST API request that is processed on a z/OS Connect server running on a specific Sysplex and LPAR*Shown as millisecond*                                                                                                                                                             |
| **ziris.zos.connect.http.request.methods**(gauge)                                                                                            | Number of different HTTP request method types that are processed on a z/OS Connect server on a specific Sysplex and host*Shown as method*                                                                                                                                                                             |
| **ziris.zos.connect.http.response.codes**(gauge)                                                                                             | The count of different HTTP response codes from a REST API processed on the z/OS Connect server*Shown as occurrence*                                                                                                                                                                                                  |
| **ziris.zos.connect.request.types**(gauge)                                                                                                   | The number of HTTP REST API request types that are processed on a z/OS Connect server on a specific Sysplex and host*Shown as operation*                                                                                                                                                                              |
| **ziris.zos.connect.sor.elapsed\_time**(gauge)                                                                                               | The elapsed time of a z/OS Connect REST API request within the system of record (CICS, IMS, MQ, Db2) on a specific Sysplex and host*Shown as millisecond*                                                                                                                                                             |
| **ziris.zos.connect.sor.latency**(gauge)                                                                                                     | The latency of a REST API request that the z/OS Connect server receives and the system of record processes on a specific Sysplex and host*Shown as millisecond*                                                                                                                                                       |
| **ziris.zos.connect.sor.request.duration**(gauge)                                                                                            | The aggregated distribution of duration for API requests processed in the system of record (sor) e.g. CICS, IMS, DB2, MQ*Shown as millisecond*                                                                                                                                                                        |
| **ziris.zos.connect.successful\_requests**(gauge)                                                                                            | The number of successful REST API requests processed by a z/OS Connect server on a specific Sysplex and host*Shown as request*                                                                                                                                                                                        |
| **ziris.zos.connect.timed\_out\_requests**(gauge)                                                                                            | The number of timed out REST API requests processed by a z/OS Connect server on a specific Sysplex and host*Shown as timeout*                                                                                                                                                                                         |
| **ziris.zos.connect.zcon\_elapsed\_time**(gauge)                                                                                             | The elapsed time of a REST API request in a z/OS Connect server on a specific Sysplex and host. This measurement excludes the time that is spent within the system of record.*Shown as millisecond*                                                                                                                   |
| **ziris.zos.cpu.in\_ready\_work\_queue\_contention**(gauge)                                                                                  | Specifies the sum of the distribution of in-ready work that is represented in zos.cpu.in_ready_work_queue_utilization. Identifies CPU contention (competition for CPU resources)*Shown as percent*                                                                                                                    |
| **ziris.zos.cpu.in\_ready\_work\_queue\_utilization**(gauge)                                                                                 | A distribution of samples taken when units of work are in central storage and ready to execute or are executing on online logical processors.*Shown as percent*                                                                                                                                                       |
| **ziris.zos.cpu.mvs.lpar.utilization**(gauge)                                                                                                | To filter this metric based on the processor type, the attribute cpu.type can have one of two values:*Shown as percent*                                                                                                                                                                                               |
| **ziris.zos.cpu.mvs.utilization**(gauge)                                                                                                     | The CPU utilization of an MVS system running in a specific LPAR (host.name) and a specific Sysplex*Shown as percent*                                                                                                                                                                                                  |
| **ziris.zos.jvm.gc.duration**(gauge)                                                                                                         | Duration of JVM GC actions from JVMs that are monitored by SYSVIEW.*Shown as second*                                                                                                                                                                                                                                  |
| **ziris.zos.jvm.memory.committed\_after\_last\_gc**(gauge)                                                                                   | Measure of memory committed after last garbage collection from JVMs that are monitored by SYSVIEW.*Shown as byte*                                                                                                                                                                                                     |
| **ziris.zos.jvm.memory.committed\_before\_last\_gc**(gauge)                                                                                  | Measure of memory committed before last garbage collection from JVMs that are monitored by SYSVIEW.*Shown as byte*                                                                                                                                                                                                    |
| **ziris.zos.jvm.memory.init**(gauge)                                                                                                         | Initial requested memory from JVMs that are monitored by SYSVIEW.*Shown as second*                                                                                                                                                                                                                                    |
| **ziris.zos.jvm.memory.limit**(gauge)                                                                                                        | Measure of max obtainable memory from JVMs that are monitored by SYSVIEW.*Shown as byte*                                                                                                                                                                                                                              |
| **ziris.zos.jvm.memory.used\_after\_last\_gc**(gauge)                                                                                        | Measure of memory used, as measured after the most recent garbage collection event on this pool from JVMs that are monitored by SYSVIEW.*Shown as byte*                                                                                                                                                               |
| **ziris.zos.jvm.memory.used\_before\_last\_gc**(gauge)                                                                                       | Measure of memory used before last garbage collection from JVMs that are monitored by SYSVIEW.*Shown as byte*                                                                                                                                                                                                         |

## Uninstallation{% #uninstallation %}

1. Stop the OpenTelemetry Collector or disable the Datadog Exporter.
1. In Datadog, open the WatchTower z/IRIS integration tile and click **Uninstall**.

## Support{% #support %}

Need help? Contact Broadcom by visiting [support.broadcom.com](https://support.broadcom.com/) and creating a support case for WatchTower z/IRIS.
