---
title: VoltDB
description: Collect status, performance and other metrics from a VoltDB cluster.
breadcrumbs: Docs > Integrations > VoltDB
---
# VoltDB
Supported OS Integration version6.4.1
## Overview{% #overview %}
This check monitors [VoltDB](https://voltdb.com) through the Datadog Agent.
**Minimum Agent version:** 7.26.0
## Setup{% #setup %}
Follow the instructions below to install and configure this check for an Agent running on a host. For containerized environments, see the [Autodiscovery Integration Templates](https://docs.datadoghq.com/agent/kubernetes/integrations.md) for guidance on applying these instructions.
**Note**: This check should only be configured on one Agent per cluster. If you are monitoring a cluster spread across several hosts, install an Agent on each host. However, do not enable the VoltDB integration on more than one host, as this results in duplicate metrics.
### Installation{% #installation %}
The VoltDB check is included in the [Datadog Agent](https://app.datadoghq.com/account/settings/agent/latest) package. No additional installation is needed on your server.
### Configuration{% #configuration %}
1. Add a `datadog-agent` user. You can do so by editing your VoltDB `deployment.xml` file. **Note**: No specific roles are required, so assign the built-in `user` role.
```xml
```
1. Edit the `voltdb.d/conf.yaml` file, in the `conf.d/` folder at the root of your Agent's configuration directory to start collecting your VoltDB performance data. See the [sample voltdb.d/conf.yaml](https://github.com/DataDog/integrations-core/blob/master/voltdb/datadog_checks/voltdb/data/conf.yaml.example) for all available configuration options.
```yaml
init_config:
instances:
- url: http://localhost:8080
username: datadog-agent
password: ""
```
1. [Restart the Agent](https://docs.datadoghq.com/agent/guide/agent-commands.md#start-stop-and-restart-the-agent).
#### TLS support{% #tls-support %}
If [TLS/SSL](https://docs.voltdb.com/UsingVoltDB/SecuritySSL.php) is enabled on the client HTTP port:
1. Export your certificate CA file in PEM format:
```bash
keytool -exportcert -file /path/to/voltdb-ca.pem -keystore -storepass -alias voltdb -rfc
```
1. Export your certificate in PEM format:
```bash
openssl pkcs12 -nodes -in -out /path/to/voltdb.pem -password pass:
```
The resulting file should contain the *unencrypted* private key and the certificate:
```
-----BEGIN PRIVATE KEY-----
-----END PRIVATE KEY-----
-----BEGIN CERTIFICATE-----
-----END CERTIFICATE-----
```
1. In your instance configuration, point `url` to the TLS-enabled client endpoint, and set the `tls_cert` and `tls_ca_cert` options. For example:
```yaml
instances:
- # ...
url: https://localhost:8443
tls_cert: /path/to/voltdb.pem
tls_ca_cert: /path/to/voltdb-ca.pem
```
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, enable it in your `datadog.yaml` file:
```yaml
logs_enabled: true
```
1. Add this configuration block to your `voltdb.d/conf.yaml` file to start collecting your VoltDB logs:
```yaml
logs:
- type: file
path: /var/log/voltdb.log
source: voltdb
```
Change the `path` value based on your environment. See the [sample `voltdb.d/conf.yaml` file](https://github.com/DataDog/integrations-core/blob/master/voltdb/datadog_checks/voltdb/data/conf.yaml.example) for all available configuration options.
[Restart the Agent](https://docs.datadoghq.com/agent/guide/agent-commands.md#start-stop-and-restart-the-agent).
To enable logs for Kubernetes environments, see [Kubernetes Log Collection](https://docs.datadoghq.com/agent/kubernetes/log.md).
### Validation{% #validation %}
[Run the Agent's status subcommand](https://docs.datadoghq.com/agent/guide/agent-commands.md#agent-status-and-information) and look for `voltdb` under the Checks section.
## Data Collected{% #data-collected %}
### Metrics{% #metrics %}
| |
| |
| **voltdb.commandlog.fsync\_interval**(gauge) | Average interval between the last 10 fsync system calls.*Shown as millisecond* |
| **voltdb.commandlog.in\_use\_segment\_count**(gauge) | The number of segment files currently in use for command logging. |
| **voltdb.commandlog.outstanding\_bytes**(gauge) | Size of pending command log data: data for transactions that have been initiated but the log has yet to be written to the disk. For synchronous logging this value is always zero.*Shown as byte* |
| **voltdb.commandlog.outstanding\_transactions**(gauge) | The number of transactions of pending command log data: the number of transactions that have been initiated for which the log has yet to be written to disk. For synchronous logging this value is always zero. |
| **voltdb.commandlog.segment\_count**(gauge) | The number of segment files allocated (including currently unused segments). |
| **voltdb.cpu.percent\_used**(gauge) | Percentage of total CPU available used by the database server process.*Shown as percent* |
| **voltdb.export.latency.avg**(gauge) | The average time between when records are inserted and when they are acknowledged by the target.*Shown as millisecond* |
| **voltdb.export.latency.max**(gauge) | The maximum time between when a record was inserted and when it was acknowledged by the target.*Shown as millisecond* |
| **voltdb.export.queue\_gap**(gauge) | The number of records missing from the queue for the current stream and partition. |
| **voltdb.export.records\_pending**(gauge) | The number of records out of TUPLE_COUNT still waiting to be written to or acknowledged by the target. |
| **voltdb.export.records\_queued**(count) | The number of records queued to the export target. |
| **voltdb.export.time\_since\_last\_acked**(gauge) | Time since the last tuple was acknowledged as received by the target.*Shown as second* |
| **voltdb.export.time\_since\_last\_queued**(gauge) | Time since the most recent tuple was added to the export queue for this partition.*Shown as second* |
| **voltdb.gc.newgen\_avg\_gc\_time**(gauge) | Average time taken by young generation collections.*Shown as millisecond* |
| **voltdb.gc.newgen\_gc\_count**(count) | Total number of times young generation garbage collection was performed. |
| **voltdb.gc.oldgen\_avg\_gc\_time**(gauge) | Average time taken by young generation collections.*Shown as millisecond* |
| **voltdb.gc.oldgen\_gc\_count**(count) | Total number of times old generation garbage collection was performed. |
| **voltdb.idletime.avg\_wait**(gauge) | The average amount of time the execution site had to wait for a new task (in microseconds).*Shown as microsecond* |
| **voltdb.idletime.max\_wait**(gauge) | The maximum amount of time the execution site had to wait for a new task (in nanoseconds).*Shown as microsecond* |
| **voltdb.idletime.min\_wait**(gauge) | The minimum amount of time the execution site had to wait for a new task (in nanoseconds).*Shown as microsecond* |
| **voltdb.idletime.stddev**(gauge) | The standard deviation of the waiting time (in microseconds).*Shown as microsecond* |
| **voltdb.idletime.wait.count**(count) | The number of times the execution site had to wait for a new task (that is, the queue was empty). |
| **voltdb.idletime.wait.pct**(gauge) | The percentage of time the execution site was waiting for a new task (that is, the site was idle). |
| **voltdb.idletime.wait.total**(gauge) | The cumulative number of times the execution site had to wait for a new task (that is, the queue was empty). |
| **voltdb.import.failures.count**(count) | The number of import transactions that failed. |
| **voltdb.import.failures.total**(gauge) | The cumulative number of import transactions that failed. |
| **voltdb.import.outstanding\_requests**(gauge) | The number of records read from the import stream and waiting to be inserted into the database.*Shown as record* |
| **voltdb.import.retries.count**(count) | The number of attempts to replay failed transactions. |
| **voltdb.import.retries.total**(gauge) | The cumulative number of attempts to replay failed transactions. |
| **voltdb.import.successes.count**(count) | The number of import transactions that succeeded. |
| **voltdb.import.successes.total**(gauge) | The cumulative number of import transactions that succeeded. |
| **voltdb.index.entry\_count**(gauge) | Number of index entries currently in the partition. |
| **voltdb.index.memory\_estimate**(gauge) | Estimated amount of memory consumed by the current index entries.*Shown as kibibyte* |
| **voltdb.io.bytes\_read**(count) | Total number of bytes of data sent from the client to the host.*Shown as byte* |
| **voltdb.io.bytes\_written**(count) | Total number of bytes of data sent from the host to the client.*Shown as byte* |
| **voltdb.io.messages\_read**(count) | Total number of individual messages sent from the client to the host.*Shown as byte* |
| **voltdb.io.messages\_written**(count) | Total number of individual messages sent from the host to the client.*Shown as byte* |
| **voltdb.latency.count**(gauge) | Number of transactions during the interval. |
| **voltdb.latency.interval**(gauge) | Length of the measurement interval: five seconds (5000).*Shown as millisecond* |
| **voltdb.latency.max**(gauge) | Maximum latency during the interval*Shown as microsecond* |
| **voltdb.latency.p50**(gauge) | 50th percentile latency.*Shown as microsecond* |
| **voltdb.latency.p95**(gauge) | 95th percentile latency.*Shown as microsecond* |
| **voltdb.latency.p99**(gauge) | 99th percentile latency.*Shown as microsecond* |
| **voltdb.latency.p999**(gauge) | 99.9th percentile latency.*Shown as microsecond* |
| **voltdb.latency.p9999**(gauge) | 99.99th percentile latency.*Shown as microsecond* |
| **voltdb.latency.p99999**(gauge) | 99.999th percentile latency.*Shown as microsecond* |
| **voltdb.latency.transactions\_per\_sec**(gauge) | Number of transactions per second during the interval*Shown as transaction* |
| **voltdb.memory.index**(gauge) | Amount of memory currently in use for storing database indexes.*Shown as kibibyte* |
| **voltdb.memory.java.max\_heap**(gauge) | Maximum heap size of the Java runtime environment.*Shown as kibibyte* |
| **voltdb.memory.java.unused**(gauge) | Amount of memory allocated by Java but unused (free space in the Java heap).*Shown as kibibyte* |
| **voltdb.memory.java.used**(gauge) | Amount of memory allocated by Java and currently in use by VoltDB.*Shown as kibibyte* |
| **voltdb.memory.physical**(gauge) | Total size of physical memory on the server.*Shown as kibibyte* |
| **voltdb.memory.pooled**(gauge) | Total size of memory allocated for tasks other than database records, indexes, and strings.*Shown as kibibyte* |
| **voltdb.memory.rss**(gauge) | Total amount of memory allocated to the VoltDB processes on the server.*Shown as kibibyte* |
| **voltdb.memory.string**(gauge) | Amount of memory currently in use for storing string, binary and geospatial data that is not stored inline in the database record.*Shown as kibibyte* |
| **voltdb.memory.tuple\_allocated**(gauge) | Amount of memory allocated for the storage of database records (including free space).*Shown as kibibyte* |
| **voltdb.memory.tuple\_count**(gauge) | Total number of database records currently in memory.*Shown as kibibyte* |
| **voltdb.memory.tuple\_data**(gauge) | Amount of memory currently in use for storing database records.*Shown as kibibyte* |
| **voltdb.procedure.aborts**(count) | Total number of times the procedure was aborted.*Shown as byte* |
| **voltdb.procedure.avg\_execution\_time**(gauge) | Average amount of time it took to execute the stored procedure.*Shown as nanosecond* |
| **voltdb.procedure.avg\_parameter\_set\_size**(gauge) | Average size of the parameters passed as input to the procedure.*Shown as byte* |
| **voltdb.procedure.avg\_result\_size**(gauge) | Average size of the results returned by the procedure.*Shown as byte* |
| **voltdb.procedure.failures**(count) | Total number of times the procedure failed unexpectedly.*Shown as byte* |
| **voltdb.procedure.invocations**(count) | The number of invocations of this procedure at this site. |
| **voltdb.procedure.max\_execution\_time**(gauge) | Maximum amount of time it took to execute the stored procedure.*Shown as nanosecond* |
| **voltdb.procedure.max\_parameter\_set\_size**(gauge) | Maximum size of the parameters passed as input to the procedure.*Shown as byte* |
| **voltdb.procedure.max\_result\_size**(gauge) | Maximum size of the results returned by the procedure.*Shown as byte* |
| **voltdb.procedure.min\_execution\_time**(gauge) | Minimum amount of time it took to execute the stored procedure.*Shown as nanosecond* |
| **voltdb.procedure.min\_parameter\_set\_size**(gauge) | Minimim size of the parameters passed as input to the procedure.*Shown as byte* |
| **voltdb.procedure.min\_result\_size**(gauge) | Minimum size of the results returned by the procedure.*Shown as byte* |
| **voltdb.procedure.successes**(count) | Total number of times the procedure succeeded.*Shown as byte* |
| **voltdb.procedure.timed\_invocations**(count) | Total number of invocations used to measure the minimum, maximum, and average execution time. |
| **voltdb.procedureoutput.avg\_result\_size**(gauge) | The average result set size in bytes.*Shown as byte* |
| **voltdb.procedureoutput.invocations.count**(count) | The number of invocations of this procedure. |
| **voltdb.procedureoutput.invocations.total**(gauge) | The cumulative number of invocations of this procedure. |
| **voltdb.procedureoutput.max\_result\_size**(gauge) | The maximum result set size in bytes.*Shown as byte* |
| **voltdb.procedureoutput.min\_result\_size**(gauge) | The minimum result set size in bytes.*Shown as byte* |
| **voltdb.procedureoutput.total\_result\_size**(gauge) | The total output returned by all invocations of this stored procedure measured in megabytes.*Shown as mebibyte* |
| **voltdb.procedureoutput.weighted\_perc**(gauge) | A weighted average expressed as a percentage of the result set size returned by invocations of this stored procedure compared to all stored procedure invocations. |
| **voltdb.procedureprofile.aborts.count**(count) | The number of times the procedure was aborted. |
| **voltdb.procedureprofile.aborts.total**(gauge) | The cumulative number of times the procedure was aborted. |
| **voltdb.procedureprofile.avg\_time**(gauge) | The average length of time (in nanoseconds) it took to execute the stored procedure.*Shown as nanosecond* |
| **voltdb.procedureprofile.failures.count**(count) | The number of times the procedure failed unexpectedly (as opposed to user aborts or expected errors, such as constraint violations). |
| **voltdb.procedureprofile.failures.total**(gauge) | The number of times the procedure failed unexpectedly (as opposed to user aborts or expected errors, such as constraint violations). |
| **voltdb.procedureprofile.invocations.count**(count) | The number of invocations of this procedure. |
| **voltdb.procedureprofile.invocations.total**(gauge) | The total number of invocations of this procedure. |
| **voltdb.procedureprofile.max\_time**(gauge) | The maximum length of time (in nanoseconds) it took to execute the stored procedure.*Shown as nanosecond* |
| **voltdb.procedureprofile.min\_time**(gauge) | The minimum length of time (in nanoseconds) it took to execute the stored procedure.*Shown as nanosecond* |
| **voltdb.procedureprofile.weighted\_perc**(gauge) | A weighted average expressed as a percentage of the execution time for this stored procedure compared to all stored procedure invocations. |
| **voltdb.queue.avg\_wait**(gauge) | The average length of time (in microseconds) tasks were waiting in the queue in the last five seconds.*Shown as microsecond* |
| **voltdb.queue.current\_depth**(gauge) | The number of tasks currently in the queue.*Shown as task* |
| **voltdb.queue.max\_wait**(gauge) | The maximum length of time (in microseconds) tasks were waiting in the queue in the last five seconds.*Shown as microsecond* |
| **voltdb.queue.poll\_count\_per\_sec**(gauge) | The number of tasks that left the queue*Shown as task* |
| **voltdb.snapshot\_status.duration**(gauge) | Amount of time it took to complete the snapshot.*Shown as second* |
| **voltdb.snapshot\_status.size**(gauge) | Total size of the snapshot file.*Shown as byte* |
| **voltdb.snapshot\_status.throughput**(gauge) | Average number of bytes per second written to the file during the snapshot process.*Shown as byte* |
| **voltdb.table.percent\_full**(gauge) | Percentage of the row limit currently in use by table rows in this partition. If no row limit is set this is zero.*Shown as percent* |
| **voltdb.table.string\_data\_memory**(gauge) | Total memory used for storing non-inline variable length data associated with this table in this partition.*Shown as kibibyte* |
| **voltdb.table.tuple\_allocated\_memory**(gauge) | Total size of memory allocated for storing inline data associated with this table in this partition. Can exceed currently used memory.*Shown as kibibyte* |
| **voltdb.table.tuple\_count**(gauge) | Number of rows currently stored for this table in the current partition. |
| **voltdb.table.tuple\_data\_memory**(gauge) | Total memory used for storing inline data associated with this table and this partition.*Shown as kibibyte* |
| **voltdb.table.tuple\_limit**(gauge) | The row limit for this table. Row limits are optional and are defined in the schema as a maximum number of rows that any partition can contain. If no row limit is set, this value is null.*Shown as row* |
### Events{% #events %}
This check does not include any events.
### Service Checks{% #service-checks %}
**voltdb.can\_connect**
Returns `CRITICAL` if the Agent is unable to reach the configured VoltDB client URL, `OK` otherwise.
*Statuses: ok, critical*
## Troubleshooting{% #troubleshooting %}
Need help? Contact [Datadog support](https://docs.datadoghq.com/help/).