Join us at the Dash conference! July 16-17, NYC

IBM Db2

Agent Check Agent Check

Supported OS: Linux Mac OS Windows

Overview

This check monitors IBM Db2 through the Datadog Agent.

Setup

Installation

The IBM Db2 check is included in the Datadog Agent package.

Dependencies

The ibm_db client library is required. To install it, ensure you have a working compiler and run:

Unix:

/opt/datadog-agent/embedded/bin/pip install ibm_db==3.0.1

Windows:

"C:\Program Files\Datadog\Datadog Agent\embedded\Scripts\python.exe" -m pip install ibm_db==3.0.1

Additionally, on Linux there may be need for XML functionality. If you encounter errors during the build process, install libxslt-dev (or libxslt-devel for RPM).

Privileges

To query metrics from certain tables, specific privileges must be granted to the chosen Db2 user. Switch to the instance master user and run these commands at the db2 prompt:

update dbm cfg using HEALTH_MON on
update dbm cfg using DFT_MON_STMT on
update dbm cfg using DFT_MON_LOCK on
update dbm cfg using DFT_MON_TABLE on
update dbm cfg using DFT_MON_BUFPOOL on

Now if you run get dbm cfg, you should see the following:

 Default database monitor switches
   Buffer pool                         (DFT_MON_BUFPOOL) = ON
   Lock                                   (DFT_MON_LOCK) = ON
   Sort                                   (DFT_MON_SORT) = OFF
   Statement                              (DFT_MON_STMT) = ON
   Table                                 (DFT_MON_TABLE) = ON
   Timestamp                         (DFT_MON_TIMESTAMP) = ON
   Unit of work                            (DFT_MON_UOW) = OFF
 Monitor health of instance and databases   (HEALTH_MON) = ON

Configuration

  1. Edit the ibm_db2.d/conf.yaml file, in the conf.d/ folder at the root of your Agent’s configuration directory to start collecting your ibm_db2 performance data. See the sample ibm_db2.d/conf.yaml for all available configuration options.

  2. Restart the Agent.

Validation

Run the Agent’s status subcommand and look for ibm_db2 under the Checks section.

Data Collected

Metrics

ibm_db2.application.active
(gauge)
The number of applications that are currently connected to the database.
shown as connection
ibm_db2.application.executing
(gauge)
The number of applications for which the database manager is currently processing a request.
shown as connection
ibm_db2.connection.active
(gauge)
The current number of connections.
shown as connection
ibm_db2.connection.max
(gauge)
The highest number of simultaneous connections to the database since the database was activated.
shown as connection
ibm_db2.connection.total
(count)
The total number of connections to the database since the first connect, activate, or last reset (coordinator agents).
shown as connection
ibm_db2.lock.dead
(count)
The total number of deadlocks that have occurred.
shown as lock
ibm_db2.lock.waiting
(gauge)
The number of agents waiting on a lock.
shown as lock
ibm_db2.lock.active
(gauge)
The number of locks currently held.
shown as lock
ibm_db2.lock.wait
(gauge)
The average wait time for a lock.
shown as millisecond
ibm_db2.lock.pages
(gauge)
The memory pages (4 KiB each) currently in use by the lock list.
shown as page
ibm_db2.lock.timeouts
(count)
The number of times that a request to lock an object timed out instead of being granted.
shown as lock
ibm_db2.backup.latest
(gauge)
The time elapsed since the latest database backup was completed.
shown as second
ibm_db2.row.modified.total
(count)
The total number of rows inserted, updated, or deleted.
shown as row
ibm_db2.row.reads.total
(count)
The total number of rows that had to be read in order to return result sets.
shown as row
ibm_db2.row.returned.total
(count)
The total number of rows that have been selected by and returned to applications.
shown as row
ibm_db2.bufferpool.column.reads.physical
(count)
The number of column-organized table data pages read from the physical table space containers for temporary, regular, and large table spaces.
shown as get
ibm_db2.bufferpool.column.reads.logical
(count)
The number of column-organized table data pages read from the logical table space containers for temporary, regular, and large table spaces.
shown as get
ibm_db2.bufferpool.column.reads.total
(count)
The total number of column-organized table data pages read from the table space containers for temporary, regular, and large table spaces.
shown as get
ibm_db2.bufferpool.column.hit_percent
(gauge)
The percentage of time that the database manager did not need to load a page from disk to service a column-organized table data page request.
shown as percent
ibm_db2.bufferpool.data.reads.physical
(count)
The number of data pages read from the physical table space containers for temporary, regular and large table spaces.
shown as get
ibm_db2.bufferpool.data.reads.logical
(count)
The number of data pages read from the logical table space containers for temporary, regular and large table spaces.
shown as get
ibm_db2.bufferpool.data.reads.total
(count)
The total number of data pages read from the table space containers for temporary, regular and large table spaces.
shown as get
ibm_db2.bufferpool.data.hit_percent
(gauge)
The percentage of time that the database manager did not need to load a page from disk to service a data page request.
shown as percent
ibm_db2.bufferpool.index.reads.physical
(count)
The number of index pages read from the physical table space containers for temporary, regular and large table spaces.
shown as get
ibm_db2.bufferpool.index.reads.logical
(count)
The number of index pages read from the logical table space containers for temporary, regular and large table spaces.
shown as get
ibm_db2.bufferpool.index.reads.total
(count)
The total number of index pages read from the table space containers for temporary, regular and large table spaces.
shown as get
ibm_db2.bufferpool.index.hit_percent
(gauge)
The percentage of time that the database manager did not need to load a page from disk to service an index page request.
shown as percent
ibm_db2.bufferpool.xda.reads.physical
(count)
The number of data pages for XML storage objects (XDAs) read from the physical table space containers for temporary, regular and large table spaces.
shown as get
ibm_db2.bufferpool.xda.reads.logical
(count)
The number of data pages for XML storage objects (XDAs) read from the logical table space containers for temporary, regular and large table spaces.
shown as get
ibm_db2.bufferpool.xda.reads.total
(count)
The total number of data pages for XML storage objects (XDAs) read from the table space containers for temporary, regular and large table spaces.
shown as get
ibm_db2.bufferpool.xda.hit_percent
(gauge)
The percentage of time that the database manager did not need to load a page from disk to service an index page request.
shown as percent
ibm_db2.bufferpool.reads.physical
(count)
The number of pages read from the physical table space containers for temporary, regular and large table spaces.
shown as get
ibm_db2.bufferpool.reads.logical
(count)
The number of pages read from the logical table space containers for temporary, regular and large table spaces.
shown as get
ibm_db2.bufferpool.reads.total
(count)
The total number of pages read from the table space containers for temporary, regular and large table spaces.
shown as get
ibm_db2.bufferpool.hit_percent
(gauge)
The percentage of time that the database manager did not need to load a page from disk to service a page request.
shown as percent
ibm_db2.bufferpool.group.column.hit_percent
(gauge)
The percentage of time that the group database manager did not need to load a page from disk to service a column-organized table data page request.
shown as percent
ibm_db2.bufferpool.group.data.hit_percent
(gauge)
The percentage of time that the group database manager did not need to load a page from disk to service a data page request.
shown as percent
ibm_db2.bufferpool.group.index.hit_percent
(gauge)
The percentage of time that the group database manager did not need to load a page from disk to service an index page request.
shown as percent
ibm_db2.bufferpool.group.xda.hit_percent
(gauge)
The percentage of time that the group database manager did not need to load a page from disk to service an index page request.
shown as percent
ibm_db2.bufferpool.group.hit_percent
(gauge)
The percentage of time that the group database manager did not need to load a page from disk to service a page request.
shown as percent
ibm_db2.tablespace.size
(gauge)
The total size of the table space in bytes.
shown as byte
ibm_db2.tablespace.usable
(gauge)
The total usable size of the table space in bytes.
shown as byte
ibm_db2.tablespace.used
(gauge)
The total used size of the table space in bytes.
shown as byte
ibm_db2.tablespace.utilized
(gauge)
The utilization of the table space as a percentage.
shown as percent
ibm_db2.log.used
(gauge)
The disk blocks (4 KiB each) of active log space currently used in the database.
shown as block
ibm_db2.log.available
(gauge)
The disk blocks (4 KiB each) of active log space in the database that is not being used by uncommitted transactions.
shown as block
ibm_db2.log.utilized
(gauge)
The utilization of active log space as a percentage.
shown as percent
ibm_db2.log.reads
(count)
The number of log pages read from disk by the logger.
shown as read
ibm_db2.log.writes
(count)
The number of log pages written to disk by the logger.
shown as write

Service Checks

  • ibm_db2.can_connect returns CRITICAL if the Agent is unable to connect to the monitored IBM Db2 database, otherwise returns OK.
  • ibm_db2.status returns CRITICAL if the monitored IBM Db2 database is quiesced, WARNING for quiesce-pending or rollforwards, otherwise returns OK.

Events

  • ibm_db2.tablespace_state_change is triggered whenever the state of a tablespace changes.

Troubleshooting

Need help? Contact Datadog support.


Mistake in the docs? Feel free to contribute!