---
title: Hbase region server
description: HBase regionserver integration.
breadcrumbs: Docs > Integrations > Hbase region server
---

# Hbase region server
Supported OS Integration version1.0.0
## Overview{% #overview %}

Get metrics from the HBase RegionServer service in real time to:

- Visualize and monitor HBase RegionServer states.
- Be notified about HBase RegionServer failovers and events.

## Setup{% #setup %}

The HBase RegionServer check is not included in the [Datadog Agent](https://app.datadoghq.com/account/settings/agent/latest) package, so you need to install it.

### Installation{% #installation %}

For Agent v7.21+ / v6.21+, follow the instructions below to install the HBase RegionServer check on your host. See [Use Community Integrations](https://docs.datadoghq.com/agent/guide/use-community-integrations.md) to install with the Docker Agent or earlier versions of the Agent.

1. Run the following command to install the Agent integration:

   ```shell
   datadog-agent integration install -t datadog-hbase_regionserver==<INTEGRATION_VERSION>
   ```

1. Configure your integration similar to core [integrations](https://docs.datadoghq.com/getting_started/integrations.md).

### Configuration{% #configuration %}

1. Edit the `hbase_regionserver.d/conf.yaml` file in the `conf.d/` folder at the root of your [Agent's configuration directory](https://docs.datadoghq.com/agent/guide/agent-configuration-files.md#agent-configuration-directory) to start collecting your HBase RegionServer metrics. See the [sample hbase_regionserver.d/conf.yaml](https://github.com/DataDog/integrations-extras/blob/master/hbase_regionserver/datadog_checks/hbase_regionserver/data/conf.yaml.example) for all available configuration options.

1. [Restart the Agent](https://docs.datadoghq.com/agent/guide/agent-commands.md#start-stop-and-restart-the-agent)

### Log collection{% #log-collection %}

1. Collecting logs is disabled by default in the Datadog Agent, you need to enable it in `datadog.yaml`:

   ```yaml
   logs_enabled: true
   ```

1. Add this configuration block to your `hbase_regionserver.d/conf.yaml` file to start collecting your Hbase_regionserver Logs:

   ```yaml
   logs:
     - type: file
       path: /path/to/my/directory/file.log
       source: hbase
   ```

Change the `path` parameter value and configure it for your environment. See the [sample hbase_regionserver.d/conf.yaml](https://github.com/DataDog/integrations-extras/blob/master/hbase_regionserver/datadog_checks/hbase_regionserver/data/conf.yaml.example) for all available configuration options.

1. [Restart the Agent](https://docs.datadoghq.com/agent/guide/agent-commands.md#start-stop-and-restart-the-agent).

## Validation{% #validation %}

Run the [Agent's status subcommand](https://docs.datadoghq.com/agent/guide/agent-commands.md#service-status) and look for `hbase_regionserver` under the Checks section.

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

### Metrics{% #metrics %}

|  |
|  |
| **hbase.regionserver.ipc.queue\_size**(gauge)                                  | Number of bytes in the call queues.*Shown as byte*                                                             |
| **hbase.regionserver.ipc.num\_open\_connections**(gauge)                       | Number of open connections.                                                                                    |
| **hbase.regionserver.ipc.num\_active\_handler**(gauge)                         | Number of active rpc handlers.                                                                                 |
| **hbase.regionserver.ipc.total\_call\_time.max**(gauge)                        | total call time, including both queued and processing time.*Shown as millisecond*                              |
| **hbase.regionserver.ipc.total\_call\_time.mean**(gauge)                       | total call time, including both queued and processing time.*Shown as millisecond*                              |
| **hbase.regionserver.ipc.total\_call\_time.median**(gauge)                     | total call time, including both queued and processing time.*Shown as millisecond*                              |
| **hbase.regionserver.ipc.total\_call\_time.percentile.99**(gauge)              | total call time, including both queued and processing time.*Shown as millisecond*                              |
| **hbase.regionserver.regions.num\_regions**(gauge)                             | Number of regions in the metrics system                                                                        |
| **hbase.regionserver.replication.sink.applied\_ops**(gauge)                    | Number of WAL entries applied on replication sink.                                                             |
| **hbase.regionserver.replication.sink.age\_of\_last\_applied\_op**(gauge)      | Replication time lag of last applied WAL entry between source and sink.*Shown as millisecond*                  |
| **hbase.regionserver.replication.sink.applied\_batches**(gauge)                | Number of WAL applying operations processd on replication sink.                                                |
| **hbase.regionserver.server.region\_count**(gauge)                             | Number of regions                                                                                              |
| **hbase.regionserver.server.store\_count**(gauge)                              | Number of Stores                                                                                               |
| **hbase.regionserver.server.hlog\_file\_count**(gauge)                         | Number of WAL Files                                                                                            |
| **hbase.regionserver.server.hlog\_file\_size**(gauge)                          | Size of all WAL Files*Shown as byte*                                                                           |
| **hbase.regionserver.server.store\_file\_count**(gauge)                        | Number of Store Files                                                                                          |
| **hbase.regionserver.server.mem\_store\_size**(gauge)                          | Size of the memstore*Shown as byte*                                                                            |
| **hbase.regionserver.server.store\_file\_size**(gauge)                         | Size of storefiles being served.*Shown as byte*                                                                |
| **hbase.regionserver.server.total\_request\_count**(gauge)                     | Total number of requests this RegionServer has answered.                                                       |
| **hbase.regionserver.server.read\_request\_count**(gauge)                      | Number of read requests this region server has answered.                                                       |
| **hbase.regionserver.server.write\_request\_count**(gauge)                     | Number of mutation requests this region server has answered.                                                   |
| **hbase.regionserver.server.check\_mutate\_failed\_count**(gauge)              | Number of Check and Mutate calls that failed the checks.                                                       |
| **hbase.regionserver.server.check\_mutate\_passed\_count**(gauge)              | Number of Check and Mutate calls that passed the checks.                                                       |
| **hbase.regionserver.server.store\_file\_index\_size**(gauge)                  | Size of indexes in storefiles on disk.*Shown as byte*                                                          |
| **hbase.regionserver.server.static\_index\_size**(gauge)                       | Uncompressed size of the static indexes.*Shown as byte*                                                        |
| **hbase.regionserver.server.static\_bloom\_size**(gauge)                       | Uncompressed size of the static bloom filters.*Shown as byte*                                                  |
| **hbase.regionserver.server.mutations\_without\_wal\_count**(count)            | Number of mutations that have been sent by clients with the write ahead logging turned off.                    |
| **hbase.regionserver.server.mutations\_without\_wal\_size**(gauge)             | Size of data that has been sent by clients with the write ahead logging turned off.*Shown as byte*             |
| **hbase.regionserver.server.percent\_files\_local**(gauge)                     | The percent of HFiles that are stored on the local hdfs data node.*Shown as percent*                           |
| **hbase.regionserver.server.percent\_files\_local\_secondary\_regions**(gauge) | The percent of HFiles used by secondary regions that are stored on the local hdfs data node.*Shown as percent* |
| **hbase.regionserver.server.split\_queue\_length**(gauge)                      | Length of the queue for splits.                                                                                |
| **hbase.regionserver.server.compaction\_queue\_length**(gauge)                 | Length of the queue for compactions.                                                                           |
| **hbase.regionserver.server.flush\_queue\_length**(gauge)                      | Length of the queue for region flushes                                                                         |
| **hbase.regionserver.server.block\_cache\_free\_size**(gauge)                  | Size of the block cache that is not occupied.*Shown as byte*                                                   |
| **hbase.regionserver.server.block\_cache\_count**(gauge)                       | Number of block in the block cache.                                                                            |
| **hbase.regionserver.server.block\_cache\_size**(gauge)                        | Size of the block cache.*Shown as byte*                                                                        |
| **hbase.regionserver.server.block\_cache\_hit\_count**(gauge)                  | Count of the hit on the block cache.                                                                           |
| **hbase.regionserver.server.block\_cache\_hit\_count\_primary**(gauge)         | Count of hit on primary replica in the block cache.                                                            |
| **hbase.regionserver.server.block\_cache\_miss\_count**(gauge)                 | Number of requests for a block that missed the block cache.                                                    |
| **hbase.regionserver.server.block\_cache\_miss\_count\_primary**(gauge)        | Number of requests for a block of primary replica that missed the block cache.                                 |
| **hbase.regionserver.server.block\_cache\_eviction\_count**(gauge)             | Count of the number of blocks evicted from the block cache.                                                    |
| **hbase.regionserver.server.block\_cache\_eviction\_count\_primary**(gauge)    | Count of the number of blocks evicted from primary replica in the block cache.                                 |
| **hbase.regionserver.server.block\_cache\_hit\_percent**(gauge)                | Percent of block cache requests that are hits*Shown as percent*                                                |
| **hbase.regionserver.server.block\_cache\_express\_hit\_percent**(gauge)       | The percent of the time that requests with the cache turned on hit the cache.*Shown as percent*                |
| **hbase.regionserver.server.block\_cache\_failed\_insertion\_count**(gauge)    | Number of times that a block cache insertion failed. Usually due to size restrictions.*Shown as millisecond*   |
| **hbase.regionserver.server.updates\_blocked\_time**(gauge)                    | Number of MS updates have been blocked so that the memstore can be flushed.*Shown as millisecond*              |
| **hbase.regionserver.server.flushed\_cells\_count**(gauge)                     | The number of cells flushed to disk                                                                            |
| **hbase.regionserver.server.compacted\_cells\_count**(gauge)                   | The number of cells processed during minor compactions                                                         |
| **hbase.regionserver.server.major\_compacted\_cells\_count**(gauge)            | The number of cells processed during major compactions                                                         |
| **hbase.regionserver.server.flushed\_cells\_size**(gauge)                      | The total amount of data flushed to disk, in bytes*Shown as byte*                                              |
| **hbase.regionserver.server.compacted\_cells\_size**(gauge)                    | The total amount of data processed during minor compactions, in bytes*Shown as byte*                           |
| **hbase.regionserver.server.major\_compacted\_cells\_size**(gauge)             | The total amount of data processed during major compactions, in bytes*Shown as byte*                           |
| **hbase.regionserver.server.blocked\_request\_count**(gauge)                   | The number of blocked requests because of memstore size is larger than blockingMemStoreSize                    |
| **hbase.regionserver.server.hedged\_read**(gauge)                              |
| **hbase.regionserver.server.hedged\_read\_wins**(gauge)                        |
| **hbase.regionserver.server.pause\_time\_with\_gc\_num\_ops**(gauge)           | *Shown as millisecond*                                                                                         |
| **hbase.regionserver.server.pause\_time\_with\_gc.min**(gauge)                 | *Shown as millisecond*                                                                                         |
| **hbase.regionserver.server.pause\_time\_with\_gc.max**(gauge)                 | *Shown as millisecond*                                                                                         |
| **hbase.regionserver.server.pause\_time\_with\_gc.mean**(gauge)                | *Shown as millisecond*                                                                                         |
| **hbase.regionserver.server.pause\_time\_with\_gc.median**(gauge)              | *Shown as millisecond*                                                                                         |
| **hbase.regionserver.server.pause\_time\_with\_gc.percentile.99**(gauge)       | *Shown as millisecond*                                                                                         |
| **hbase.regionserver.server.mutate.num\_ops**(gauge)                           |
| **hbase.regionserver.server.mutate.min**(gauge)                                |
| **hbase.regionserver.server.mutate.max**(gauge)                                |
| **hbase.regionserver.server.mutate.mean**(gauge)                               |
| **hbase.regionserver.server.mutate.median**(gauge)                             |
| **hbase.regionserver.server.mutate.percentile.99**(gauge)                      |
| **hbase.regionserver.server.slow\_append\_count**(gauge)                       | The number of Appends that took over 1000ms to complete                                                        |
| **hbase.regionserver.server.pause\_warn\_threshold\_exceeded**(gauge)          |
| **hbase.regionserver.server.slow\_delete\_count**(gauge)                       | The number of Deletes that took over 1000ms to complete                                                        |
| **hbase.regionserver.server.increment.num\_ops**(gauge)                        |
| **hbase.regionserver.server.increment.min**(gauge)                             |
| **hbase.regionserver.server.increment.max**(gauge)                             |
| **hbase.regionserver.server.increment.mean**(gauge)                            |
| **hbase.regionserver.server.increment.median**(gauge)                          |
| **hbase.regionserver.server.increment.percentile.99**(gauge)                   |
| **hbase.regionserver.server.replay.num\_ops**(gauge)                           |
| **hbase.regionserver.server.replay.min**(gauge)                                |
| **hbase.regionserver.server.replay.max**(gauge)                                |
| **hbase.regionserver.server.replay.mean**(gauge)                               |
| **hbase.regionserver.server.replay.median**(gauge)                             |
| **hbase.regionserver.server.replay.percentile.99**(gauge)                      |
| **hbase.regionserver.server.flush\_time.num\_ops**(gauge)                      | *Shown as millisecond*                                                                                         |
| **hbase.regionserver.server.flush\_time.min**(gauge)                           | *Shown as millisecond*                                                                                         |
| **hbase.regionserver.server.flush\_time.max**(gauge)                           | *Shown as millisecond*                                                                                         |
| **hbase.regionserver.server.flush\_time.mean**(gauge)                          | *Shown as millisecond*                                                                                         |
| **hbase.regionserver.server.flush\_time.median**(gauge)                        | *Shown as millisecond*                                                                                         |
| **hbase.regionserver.server.flush\_time.percentile.99**(gauge)                 | *Shown as millisecond*                                                                                         |
| **hbase.regionserver.server.pause\_info\_threshold\_exceeded**(gauge)          |
| **hbase.regionserver.server.delete.num\_ops**(gauge)                           |
| **hbase.regionserver.server.delete.min**(gauge)                                |
| **hbase.regionserver.server.delete.max**(gauge)                                |
| **hbase.regionserver.server.delete.mean**(gauge)                               |
| **hbase.regionserver.server.delete.median**(gauge)                             |
| **hbase.regionserver.server.delete.percentile.99**(gauge)                      |
| **hbase.regionserver.server.split\_request\_count**(gauge)                     | Number of splits requested                                                                                     |
| **hbase.regionserver.server.split\_success\_count**(gauge)                     | Number of successfully executed splits                                                                         |
| **hbase.regionserver.server.slow\_get\_count**(gauge)                          | The number of Gets that took over 1000ms to complete                                                           |
| **hbase.regionserver.server.get.num\_ops**(gauge)                              |
| **hbase.regionserver.server.get.min**(gauge)                                   |
| **hbase.regionserver.server.get.max**(gauge)                                   |
| **hbase.regionserver.server.get.mean**(gauge)                                  |
| **hbase.regionserver.server.get.median**(gauge)                                |
| **hbase.regionserver.server.get.percentile.99**(gauge)                         |
| **hbase.regionserver.server.scan\_next.num\_ops**(gauge)                       |
| **hbase.regionserver.server.scan\_next.min**(gauge)                            |
| **hbase.regionserver.server.scan\_next.max**(gauge)                            |
| **hbase.regionserver.server.scan\_next.mean**(gauge)                           |
| **hbase.regionserver.server.scan\_next.median**(gauge)                         |
| **hbase.regionserver.server.scan\_next.percentile.99**(gauge)                  |
| **hbase.regionserver.server.pause\_time\_without\_gc.num\_ops**(gauge)         | *Shown as millisecond*                                                                                         |
| **hbase.regionserver.server.pause\_time\_without\_gc.min**(gauge)              | *Shown as millisecond*                                                                                         |
| **hbase.regionserver.server.pause\_time\_without\_gc.max**(gauge)              | *Shown as millisecond*                                                                                         |
| **hbase.regionserver.server.pause\_time\_without\_gc.mean**(gauge)             | *Shown as millisecond*                                                                                         |
| **hbase.regionserver.server.pause\_time\_without\_gc.median**(gauge)           | *Shown as millisecond*                                                                                         |
| **hbase.regionserver.server.pause\_time\_without\_gc.percentile.99**(gauge)    | *Shown as millisecond*                                                                                         |
| **hbase.regionserver.server.slow\_put\_count**(gauge)                          | The number of Multis that took over 1000ms to complete                                                         |
| **hbase.regionserver.server.slow\_increment\_count**(gauge)                    | The number of Increments that took over 1000ms to complete                                                     |
| **hbase.regionserver.server.split\_time.num\_ops**(gauge)                      | *Shown as millisecond*                                                                                         |
| **hbase.regionserver.server.split\_time.min**(gauge)                           | *Shown as millisecond*                                                                                         |
| **hbase.regionserver.server.split\_time.max**(gauge)                           | *Shown as millisecond*                                                                                         |
| **hbase.regionserver.server.split\_time.mean**(gauge)                          | *Shown as millisecond*                                                                                         |
| **hbase.regionserver.server.split\_time.median**(gauge)                        | *Shown as millisecond*                                                                                         |
| **hbase.regionserver.server.split\_time.percentile.99**(gauge)                 | *Shown as millisecond*                                                                                         |
| **hbase.regionserver.wal.append\_size.num\_ops**(gauge)                        | size (in bytes) of the data appended to the WAL.*Shown as byte*                                                |
| **hbase.regionserver.wal.append\_size.min**(gauge)                             | size (in bytes) of the data appended to the WAL.*Shown as byte*                                                |
| **hbase.regionserver.wal.append\_size.max**(gauge)                             | size (in bytes) of the data appended to the WAL.*Shown as byte*                                                |
| **hbase.regionserver.wal.append\_size.mean**(gauge)                            | size (in bytes) of the data appended to the WAL.*Shown as byte*                                                |
| **hbase.regionserver.wal.append\_size.median**(gauge)                          | size (in bytes) of the data appended to the WAL.*Shown as byte*                                                |
| **hbase.regionserver.wal.append\_size.percentile.99**(gauge)                   | size (in bytes) of the data appended to the WAL.*Shown as byte*                                                |
| **hbase.regionserver.wal.sync\_time.num\_ops**(gauge)                          | the time it took to sync the WAL to HDFS.*Shown as millisecond*                                                |
| **hbase.regionserver.wal.sync\_time.min**(gauge)                               | the time it took to sync the WAL to HDFS.*Shown as millisecond*                                                |
| **hbase.regionserver.wal.sync\_time.max**(gauge)                               | the time it took to sync the WAL to HDFS.*Shown as millisecond*                                                |
| **hbase.regionserver.wal.sync\_time.mean**(gauge)                              | the time it took to sync the WAL to HDFS.*Shown as millisecond*                                                |
| **hbase.regionserver.wal.sync\_time.median**(gauge)                            | the time it took to sync the WAL to HDFS.*Shown as millisecond*                                                |
| **hbase.regionserver.wal.sync\_time.percentile.99**(gauge)                     | the time it took to sync the WAL to HDFS.*Shown as millisecond*                                                |
| **hbase.regionserver.wal.slow\_append\_count**(gauge)                          | Number of appends that were slow.                                                                              |
| **hbase.regionserver.wal.roll\_request**(gauge)                                | How many times a log roll has been requested total*Shown as millisecond*                                       |
| **hbase.regionserver.wal.append\_count**(gauge)                                | Number of appends to the write ahead log.                                                                      |
| **hbase.regionserver.wal.low\_replica\_roll\_request**(gauge)                  | How many times a log roll was requested due to too few DN's in the write pipeline.*Shown as millisecond*       |
| **hbase.regionserver.wal.append\_time.num\_ops**(gauge)                        | time an append to the log took.*Shown as millisecond*                                                          |
| **hbase.regionserver.wal.append\_time.min**(gauge)                             | time an append to the log took.*Shown as millisecond*                                                          |
| **hbase.regionserver.wal.append\_time.max**(gauge)                             | time an append to the log took.*Shown as millisecond*                                                          |
| **hbase.regionserver.wal.append\_time.mean**(gauge)                            | time an append to the log took.*Shown as millisecond*                                                          |
| **hbase.regionserver.wal.append\_time.median**(gauge)                          | time an append to the log took.*Shown as millisecond*                                                          |
| **hbase.regionserver.wal.append\_time.percentile.99**(gauge)                   | time an append to the log took.*Shown as millisecond*                                                          |
| **hbase.jvm\_metrics.mem\_non\_heap\_used\_in\_mb**(gauge)                     | Non-heap memory used in MB                                                                                     |
| **hbase.jvm\_metrics.mem\_non\_heap\_committed\_in\_mb**(gauge)                | Non-heap memory committed in MB                                                                                |
| **hbase.jvm\_metrics.mem\_non\_heap\_max\_in\_mb**(gauge)                      | Non-heap memory max in MB                                                                                      |
| **hbase.jvm\_metrics.mem\_heap\_used\_in\_mb**(gauge)                          | Heap memory used in MB                                                                                         |
| **hbase.jvm\_metrics.mem\_heap\_committed\_in\_mb**(gauge)                     | Heap memory committed in MB                                                                                    |
| **hbase.jvm\_metrics.mem\_heap\_max\_in\_mb**(gauge)                           | Heap memory max in MB                                                                                          |
| **hbase.jvm\_metrics.mem\_max\_in\_mb**(gauge)                                 | Max memory size in MB                                                                                          |
| **hbase.jvm\_metrics.gc\_count\_par\_new**(gauge)                              | GC Count for ParNew                                                                                            |
| **hbase.jvm\_metrics.gc\_time\_millis\_par\_new**(gauge)                       | GC Time for ParNew*Shown as millisecond*                                                                       |
| **hbase.jvm\_metrics.gc\_count\_concurrent\_mark\_sweep**(gauge)               | GC Count for ConcurrentMarkSweep                                                                               |
| **hbase.jvm\_metrics.gc\_time\_millis\_concurrent\_mark\_sweep**(gauge)        | GC Time for ConcurrentMarkSweep*Shown as millisecond*                                                          |
| **hbase.jvm\_metrics.gc\_count**(gauge)                                        | Total GC count                                                                                                 |
| **hbase.jvm\_metrics.gc\_time\_millis**(gauge)                                 | Total GC time in milliseconds*Shown as millisecond*                                                            |

### Events{% #events %}

The HBase RegionServer check does not include any events.

### Service Checks{% #service-checks %}

The HBase RegionServer check does not include any service checks.

## Troubleshooting{% #troubleshooting %}

Need help? Contact [Datadog support](http://docs.datadoghq.com/help).