---
title: Vertica
description: Monitor Vertica projection storage, license usage, and more.
breadcrumbs: Docs > Integrations > Vertica
---

# Vertica
Supported OS Integration version6.5.0
## Overview{% #overview %}

This check monitors [Vertica](https://www.vertica.com) through the Datadog Agent.

**Minimum Agent version:** 6.14.0

## Setup{% #setup %}

### Installation{% #installation %}

The Vertica 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 %}

Edit the `vertica.d/conf.yaml` file, in the `conf.d/` folder at the root of your Agent's configuration directory to start collecting your vertica performance data. See the example [vertica.d/conf.yaml](https://github.com/DataDog/integrations-core/blob/master/vertica/datadog_checks/vertica/data/conf.yaml.example) for all available configuration options.

#### Enabling SSL{% #enabling-ssl %}

The Vertica integration supports connecting to Vertica through SSL. To enable this, set `use_tls` in `conf.yaml` to `true`.

**Note**: For Vertica integration versions <=1.9.0, set `tls_verify` to `true` instead. For legacy support, if `tls_verify` is explicitly set to `true`, `use_tls` is set to `true`.

#### Prepare Vertica{% #prepare-vertica %}

Create a database user for the Datadog Agent. From [vsql](https://www.vertica.com/docs/9.2.x/HTML/Content/Authoring/Glossary/vsql.htm), connect to the database as a superuser. Then run the `CREATE USER` statement.

```text
CREATE USER datadog IDENTIFIED BY '<PASSWORD>';
```

The user used to connect to the database must be granted the [SYSMONITOR](https://www.vertica.com/docs/9.2.x/HTML/Content/Authoring/AdministratorsGuide/DBUsersAndPrivileges/Roles/SYSMONITORROLE.htm) role in order to access the monitoring system tables.

```text
GRANT SYSMONITOR TO datadog WITH ADMIN OPTION;
```

As the metrics for current license usage use the values from the most recent [audit](https://www.vertica.com/docs/9.2.x/HTML/Content/Authoring/SQLReferenceManual/Functions/VerticaFunctions/LicenseManagement/AUDIT_LICENSE_SIZE.htm), Datadog recommends scheduling audits to occur as often as possible. For more information, see the [Vertica audit license guide](https://www.vertica.com/docs/9.2.x/HTML/Content/Authoring/AdministratorsGuide/Licensing/MonitoringDatabaseSizeForLicenseCompliance.htm).

[Restart the Agent](https://docs.datadoghq.com/agent/guide/agent-commands.md?#start-stop-and-restart-the-agent) to start sending Vertica metrics to Datadog.

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

*Available for Agent versions >6.0*

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 `vertica.d/conf.yaml` file to start collecting your Vertica logs:

   ```yaml
   logs:
     - source: vertica
       type: file
       path: "/<CATALOG_PATH>/<DATABASE_NAME>/<NODE_NAME>_catalog/vertica.log"
       service: vertica
   ```

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?#agent-status-and-information) and look for `vertica` under the Checks section.

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

### Metrics{% #metrics %}

|  |
|  |
| **vertica.connection.active**(gauge)               | The current number of connections to a node.*Shown as connection*                                          |
| **vertica.connection.total**(count)                | The total number of connections to a node.*Shown as connection*                                            |
| **vertica.delete\_vectors**(gauge)                 | The total number of delete vectors.*Shown as item*                                                         |
| **vertica.disk.used**(gauge)                       | The total disk space (compressed) used in bytes.*Shown as byte*                                            |
| **vertica.disk.used.ros**(gauge)                   | [Only versions <= 10] The total ROS disk space (compressed) used in bytes.*Shown as byte*                  |
| **vertica.disk.used.wos**(gauge)                   | [Only versions <= 10] The total WOS disk space (compressed) used in bytes.*Shown as byte*                  |
| **vertica.epoch.ahm**(gauge)                       | The current epoch number.*Shown as time*                                                                   |
| **vertica.epoch.current**(gauge)                   | The AHM epoch number.*Shown as time*                                                                       |
| **vertica.epoch.last\_good**(gauge)                | The smallest (min) of all the checkpoint epochs on the cluster.*Shown as time*                             |
| **vertica.file.max**(gauge)                        | The maximum number of files that can be open at one time.*Shown as file*                                   |
| **vertica.file.open**(gauge)                       | The number of open files.*Shown as file*                                                                   |
| **vertica.ksafety.current**(gauge)                 | The number of node failures the cluster can tolerate before it shuts down automatically.*Shown as node*    |
| **vertica.ksafety.intended**(gauge)                | The designed or intended K-safety level.*Shown as node*                                                    |
| **vertica.license.expiration**(gauge)              | The time until license expiration.*Shown as second*                                                        |
| **vertica.license.latest\_audit**(gauge)           | The time elapsed since the latest license audit was triggered.*Shown as second*                            |
| **vertica.license.size**(gauge)                    | The total size of the license in bytes.*Shown as byte*                                                     |
| **vertica.license.usable**(gauge)                  | The total usable size of the license in bytes.*Shown as byte*                                              |
| **vertica.license.used**(gauge)                    | The total used size of the license in bytes.*Shown as byte*                                                |
| **vertica.license.utilized**(gauge)                | The utilization of the license as a percentage.*Shown as percent*                                          |
| **vertica.memory.swap.total**(gauge)               | The total amount of swap memory in bytes.*Shown as byte*                                                   |
| **vertica.memory.swap.usable**(gauge)              | The total usable amount of swap memory in bytes.*Shown as byte*                                            |
| **vertica.memory.swap.used**(gauge)                | The total used amount of swap memory in bytes.*Shown as byte*                                              |
| **vertica.memory.swap.utilized**(gauge)            | The utilization of swap memory as a percentage.*Shown as percent*                                          |
| **vertica.memory.total**(gauge)                    | The total amount of physical RAM in bytes.*Shown as byte*                                                  |
| **vertica.memory.usable**(gauge)                   | The total usable amount of physical RAM in bytes.*Shown as byte*                                           |
| **vertica.memory.used**(gauge)                     | The total used amount of physical RAM in bytes.*Shown as byte*                                             |
| **vertica.memory.utilized**(gauge)                 | The utilization of physical RAM as a percentage.*Shown as percent*                                         |
| **vertica.node.allowed**(gauge)                    | The number of nodes permitted for use by the license.*Shown as node*                                       |
| **vertica.node.available**(gauge)                  | The number of available nodes remaining based on the license limit.*Shown as node*                         |
| **vertica.node.delete\_vectors**(gauge)            | The number of delete vectors in nodes.*Shown as item*                                                      |
| **vertica.node.disk.used**(gauge)                  | The total disk space used by nodes in bytes.*Shown as byte*                                                |
| **vertica.node.disk.used.ros**(gauge)              | [Only versions <= 10] The ROS disk space used by nodes in bytes.*Shown as byte*                            |
| **vertica.node.disk.used.wos**(gauge)              | [Only versions <= 10] The WOS disk space used by nodes in bytes.*Shown as byte*                            |
| **vertica.node.down**(gauge)                       | The number of nodes that are currently down.*Shown as node*                                                |
| **vertica.node.resource\_requests**(gauge)         | The cumulative number of requests for threads, file handles, and memory (in kilobytes).*Shown as resource* |
| **vertica.node.ros.containers**(gauge)             | The number of ROS containers in nodes.*Shown as resource*                                                  |
| **vertica.node.row.ros**(gauge)                    | [Only versions <= 10] The number of ROS rows in nodes.*Shown as row*                                       |
| **vertica.node.row.total**(gauge)                  | The total number of rows in nodes.*Shown as row*                                                           |
| **vertica.node.row.wos**(gauge)                    | [Only versions <= 10] The number of WOS rows in nodes.*Shown as row*                                       |
| **vertica.node.total**(gauge)                      | The number of nodes currently in use.*Shown as node*                                                       |
| **vertica.processor.core**(gauge)                  | The number of processor cores in the system.*Shown as core*                                                |
| **vertica.processor.cpu**(gauge)                   | The number of system processors.*Shown as cpu*                                                             |
| **vertica.projection.delete\_vectors**(gauge)      | The number of delete vectors in projections.*Shown as item*                                                |
| **vertica.projection.disk.used**(gauge)            | The total disk space used by projections in bytes.*Shown as byte*                                          |
| **vertica.projection.disk.used.ros**(gauge)        | [Only versions <= 10] The ROS disk space used by projections in bytes.*Shown as byte*                      |
| **vertica.projection.disk.used.wos**(gauge)        | [Only versions <= 10] The WOS disk space used by projections in bytes.*Shown as byte*                      |
| **vertica.projection.ros.containers**(gauge)       | The number of ROS containers in projections.*Shown as resource*                                            |
| **vertica.projection.row.ros**(gauge)              | [Only versions <= 10] The number of ROS rows in projections.*Shown as row*                                 |
| **vertica.projection.row.total**(gauge)            | The total number of rows in projections.*Shown as row*                                                     |
| **vertica.projection.row.wos**(gauge)              | [Only versions <= 10] The number of WOS rows in projections.*Shown as row*                                 |
| **vertica.projection.total**(gauge)                | The total number of projections.*Shown as table*                                                           |
| **vertica.projection.unsafe**(gauge)               | The number of projections that are not up to date.*Shown as table*                                         |
| **vertica.projection.unsafe\_percent**(gauge)      | The percentage of projections that are not up to date.*Shown as percent*                                   |
| **vertica.projection.unsegmented**(gauge)          | The number of projections that are not segmented.*Shown as table*                                          |
| **vertica.projection.unsegmented\_percent**(gauge) | The percentage of projections that are not segmented.*Shown as percent*                                    |
| **vertica.query.active**(gauge)                    | The current number of queries running on a node.*Shown as query*                                           |
| **vertica.query.total**(count)                     | The total number of queries executed on a node.*Shown as query*                                            |
| **vertica.resource\_pool.memory.borrowed**(gauge)  | The amount of memory borrowed from the GENERAL pool by requests running against pools.*Shown as byte*      |
| **vertica.resource\_pool.memory.max**(gauge)       | The value of the MAXMEMORYSIZE parameter as defined for pools.*Shown as byte*                              |
| **vertica.resource\_pool.memory.used**(gauge)      | The amount of memory acquired by requests running against pools.*Shown as byte*                            |
| **vertica.resource\_pool.query.running**(gauge)    | The number of queries currently executing in pools.*Shown as query*                                        |
| **vertica.ros.containers**(gauge)                  | The total number of ROS containers.*Shown as resource*                                                     |
| **vertica.row.ros**(gauge)                         | [Only versions <= 10] The total number of ROS rows.*Shown as row*                                          |
| **vertica.row.total**(gauge)                       | The total number of rows.*Shown as row*                                                                    |
| **vertica.row.wos**(gauge)                         | [Only versions <= 10] The total number of WOS rows.*Shown as row*                                          |
| **vertica.socket.open**(gauge)                     | The number of open sockets.*Shown as file*                                                                 |
| **vertica.storage.latency**(gauge)                 | The latency of a storage location in seeks per second.*Shown as read*                                      |
| **vertica.storage.size**(gauge)                    | The total size of a storage location in bytes.*Shown as byte*                                              |
| **vertica.storage.speed**(gauge)                   | The time (in seconds) it takes to read 1 mebibyte from a storage location.*Shown as second*                |
| **vertica.storage.throughput**(gauge)              | The throughput of a storage location in mebibytes per second.*Shown as mebibyte*                           |
| **vertica.storage.usable**(gauge)                  | The total usable size of a storage location in bytes.*Shown as byte*                                       |
| **vertica.storage.used**(gauge)                    | The total used size of a storage location in bytes.*Shown as byte*                                         |
| **vertica.storage.utilized**(gauge)                | The utilization of a storage location as a percentage.*Shown as percent*                                   |
| **vertica.table.disk.used**(gauge)                 | The total disk space used by tables in bytes.*Shown as byte*                                               |
| **vertica.table.disk.used.ros**(gauge)             | [Only versions <= 10] The ROS disk space used by tables in bytes.*Shown as byte*                           |
| **vertica.table.disk.used.wos**(gauge)             | [Only versions <= 10] The WOS disk space used by tables in bytes.*Shown as byte*                           |
| **vertica.table.ros.containers**(gauge)            | The number of ROS containers in tables.*Shown as resource*                                                 |
| **vertica.table.row.ros**(gauge)                   | [Only versions <= 10] The number of ROS rows in tables.*Shown as row*                                      |
| **vertica.table.row.total**(gauge)                 | The total number of rows in tables.*Shown as row*                                                          |
| **vertica.table.row.wos**(gauge)                   | [Only versions <= 10] The number of WOS rows in tables.*Shown as row*                                      |
| **vertica.thread.active**(gauge)                   | The number of active threads.*Shown as thread*                                                             |
| **vertica.thread.max**(gauge)                      | The maximum number of threads that can coexist.*Shown as thread*                                           |

### Events{% #events %}

Vertica does not include any events.

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

**vertica.can\_connect**

Returns `OK` if the Agent is able to connect to the monitored Vertica database, or `CRITICAL` otherwise.

*Statuses: ok, critical*

**vertica.node\_state**

Returns `OK` for each node that is UP, `WARNING` for nodes that are on a possible path to UP, or `CRITICAL` otherwise.

*Statuses: ok, warning, critical, unknown*

## Troubleshooting{% #troubleshooting %}

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