---
title: Teradata
description: Monitor the health and performance of your Teradata Vantage Database.
breadcrumbs: Docs > Integrations > Teradata
---

# Teradata
Supported OS Integration version4.3.0
## Overview{% #overview %}

[Teradata](https://www.teradata.com/) is an enterprise-level relational database management system within a multi-cloud data platform.

This check monitors Teradata through the Datadog Agent. Enable the Datadog-Teradata integration to view Teradata performance, disk usage, and resource consumption.

**Minimum Agent version:** 7.37.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.

### Installation{% #installation %}

The Teradata check is included in the [Datadog Agent](https://app.datadoghq.com/account/settings/agent/latest) package.

#### Prepare Teradata{% #prepare-teradata %}

1. Download and install the [Teradata SQL Driver for Python](https://github.com/Teradata/python-driver#Installation) using the embedded agent pip command for your [operating system](https://docs.datadoghq.com/developers/guide/custom-python-package.md?tab=linux#pagetitle):

**Linux**

```
sudo -Hu dd-agent /opt/datadog-agent/embedded/bin/pip install teradatasql
```

**Windows**

```
%PROGRAMFILES%\Datadog\"Datadog Agent"\embedded<PYTHON_MAJOR_VERSION>\python -m pip install teradatasql
```
Create a read-only `datadog` user with proper access to your Teradata Database. Start a `BTEQ` session on your Teradata Database:
```shell
CREATE USER "datadog" AS PASSWORD="<PASSWORD>";
```

Optional, but strongly recommended: Grant a new or existing role to the `datadog` user designated for read-only monitoring purposes.

```shell
GRANT "<READ_ONLY_ROLE>" TO "datadog"; 
```

The Teradata system grants the `SELECT` privilege to PUBLIC on most [Data Dictionary views](https://docs.teradata.com/r/Teradata-VantageTM-Data-Dictionary/July-2021/Data-Dictionary-Views/Access-to-Data-Dictionary-Views/Default-PUBLIC-Privileges-for-Views) by default. All Teradata Database users have `PUBLIC` privileges.
To collect resource usage metrics, enable the [SPMA Resource Usage Table](https://docs.teradata.com/r/Teradata-VantageTM-Resource-Usage-Macros-and-Tables/July-2021/ResUsageSpma-Table). This is done with the [`ctl` Teradata Utility](https://docs.teradata.com/r/Teradata-VantageTM-Database-Utilities/July-2021/Control-GDO-Editor-ctl/Ctl-Commands/SCREEN):
```shell
# Start ctl session
ctl

# View RSS screen
screen rss

# Enable SPMA resource usage table
SPMA=yes

# Save the configuration setting
write
```

Note: The SPMA Resource Table logs statistics every 10 minutes by default. The logging interval can be configured in the `rss` screen using `ctl`. Resource Usage logging may impact database performance. To reduce the frequency of Resource Usage logging, increase the logging interval of the `Node Logging Rate` setting. See the Teradata [documentation](https://docs.teradata.com/r/Teradata-VantageTM-Resource-Usage-Macros-and-Tables/July-2021/Planning-Your-Resource-Usage-Data/Resource-Usage-Logging) for more information on Resource Usage Logging.
The Teradata integration collects disk space metrics from the DBC.DiskSpaceV system view by default. To collect additional disk space metrics on your database tables, enable the `collect_table_disk_metrics` option.
```
collect_table_disk_metrics: true
```

To filter the monitored tables, configure the `tables` option:

Specify tables to monitor with a list:

```
tables:
    - <TABLE_1>
    - <TABLE_2>
```

Customize your monitored tables by specifying a map with the `include` and `exclude` options:

```
tables:
    include:
        - <TABLE_1>
        - <TABLE_2>
    exclude:
        - <TABLE_3>
```

### Configuration{% #configuration %}

1. Edit the `teradata.d/conf.yaml` file, in the `conf.d/` folder at the root of your Agent's configuration directory to start collecting your teradata performance data. See the [sample teradata.d/conf.yaml](https://github.com/DataDog/integrations-core/blob/master/teradata/datadog_checks/teradata/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#agent-status-and-information) and look for `teradata` under the Checks section.

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

### Metrics{% #metrics %}

|  |
|  |
| **teradata.amp.cpu\_time**(gauge)                          | Number of seconds of AMP insert CPU time used by the user and account*Shown as second*                                                                                                                                                                                                 |
| **teradata.amp.cpu\_time\_norm**(gauge)                    | Normalized AMP CPU time used by the user and account*Shown as second*                                                                                                                                                                                                                  |
| **teradata.amp.disk\_io**(gauge)                           | Total number of reads and writes to disk by each AMP in the system                                                                                                                                                                                                                     |
| **teradata.db\_lock.blocks**(gauge)                        | Number of times a database lock was blocked                                                                                                                                                                                                                                            |
| **teradata.db\_lock.deadlocks**(gauge)                     | Number of times a database lock was deadlocked                                                                                                                                                                                                                                         |
| **teradata.disk\_space.alloc\_perm**(gauge)                | Current total allocation in bytes for permanent and user defined temporary table space. Table level metric tagged by `td_table` and `td_database`.*Shown as byte*                                                                                                                      |
| **teradata.disk\_space.alloc\_perm.total**(gauge)          | Current total allocation in bytes for permanent and user defined temporary table space. Database level metric tagged by `td_database`.*Shown as byte*                                                                                                                                  |
| **teradata.disk\_space.alloc\_spool**(gauge)               | Current total allocation in bytes for spool and other system defined temporary table space. Table level metric tagged by `td_table` and `td_database`.*Shown as byte*                                                                                                                  |
| **teradata.disk\_space.alloc\_spool.total**(gauge)         | Current total allocation in bytes for spool and other system defined temporary table space. Database level metric tagged by `td_database`.*Shown as byte*                                                                                                                              |
| **teradata.disk\_space.alloc\_temp**(gauge)                | Current total allocation in bytes for temporary tables space. Table level metric tagged by `td_table` and `td_database`.*Shown as byte*                                                                                                                                                |
| **teradata.disk\_space.alloc\_temp.total**(gauge)          | Current total allocation in bytes for temporary tables space. Database level metric tagged by `td_database`.*Shown as byte*                                                                                                                                                            |
| **teradata.disk\_space.curr\_perm**(gauge)                 | Permanent space per AMP currently being used. Table level metric tagged by `td_table` and `td_database`.*Shown as byte*                                                                                                                                                                |
| **teradata.disk\_space.curr\_perm.total**(gauge)           | Permanent space per AMP currently being used. Database level metric tagged by `td_database`.*Shown as byte*                                                                                                                                                                            |
| **teradata.disk\_space.curr\_persist\_spool**(gauge)       | Persistent spool space per AMP currently being used by the user. Table level metric tagged by `td_table` and `td_database`.*Shown as byte*                                                                                                                                             |
| **teradata.disk\_space.curr\_persist\_spool.total**(gauge) | Persistent spool space per AMP currently being used by the user. Database level metric tagged by `td_database`.*Shown as byte*                                                                                                                                                         |
| **teradata.disk\_space.curr\_spool**(gauge)                | Spool space per AMP currently being used by the user. Table level metric tagged by `td_table` and `td_database`.*Shown as byte*                                                                                                                                                        |
| **teradata.disk\_space.curr\_spool.total**(gauge)          | Spool space per AMP currently being used by the user. Database level metric tagged by `td_database`.*Shown as byte*                                                                                                                                                                    |
| **teradata.disk\_space.curr\_temp**(gauge)                 | The number of bytes currently used by a temporary table per virtual processor (vproc). Table level metric tagged by `td_table` and `td_database`.*Shown as byte*                                                                                                                       |
| **teradata.disk\_space.curr\_temp.total**(gauge)           | The number of bytes currently used by a temporary table per virtual processor (vproc). Database level metric tagged by `td_database`.*Shown as byte*                                                                                                                                   |
| **teradata.disk\_space.max\_perm**(gauge)                  | Maximum permanent space, in bytes, that is allocated to the database on a specified AMP. Table level metric tagged by `td_table` and `td_database`.*Shown as byte*                                                                                                                     |
| **teradata.disk\_space.max\_perm.total**(gauge)            | Maximum permanent space, in bytes, that is allocated to the database on a specified AMP. Database level metric tagged by `td_database`.*Shown as byte*                                                                                                                                 |
| **teradata.disk\_space.max\_prof\_spool**(gauge)           | The profile SPOOL space limit per AMP for the user if the user is assigned a profile which has a SPOOL space setting. Table level metric tagged by `td_table` and `td_database`.*Shown as byte*                                                                                        |
| **teradata.disk\_space.max\_prof\_spool.total**(gauge)     | The profile SPOOL space limit per AMP for the user if the user is assigned a profile which has a SPOOL space setting. Database level metric tagged by `td_database`.*Shown as byte*                                                                                                    |
| **teradata.disk\_space.max\_prof\_temp**(gauge)            | The profile TEMPORARY space limit per AMP for the user if the user is assigned a profile which has a TEMPORARY space setting. Table level metric tagged by `td_table` and `td_database`.*Shown as byte*                                                                                |
| **teradata.disk\_space.max\_prof\_temp.total**(gauge)      | The profile TEMPORARY space limit per AMP for the user if the user is assigned a profile which has a TEMPORARY space setting. Database level metric tagged by `td_database`.*Shown as byte*                                                                                            |
| **teradata.disk\_space.max\_spool**(gauge)                 | Maximum spool space, in bytes, that is allocated to the database on a specified AMP. Table level metric tagged by `td_table` and `td_database`.*Shown as byte*                                                                                                                         |
| **teradata.disk\_space.max\_spool.total**(gauge)           | Maximum spool space, in bytes, that is allocated to the database on a specified AMP. Database level metric tagged by `td_database`.*Shown as byte*                                                                                                                                     |
| **teradata.disk\_space.max\_temp**(gauge)                  | Maximum temporary space, in bytes, that is allocated to the database on a specified AMP. Table level metric tagged by `td_table` and `td_database`.*Shown as byte*                                                                                                                     |
| **teradata.disk\_space.max\_temp.total**(gauge)            | Maximum temporary space, in bytes, that is allocated to the database on a specified AMP. Database level metric tagged by `td_database`.*Shown as byte*                                                                                                                                 |
| **teradata.disk\_space.peak\_perm**(gauge)                 | Maximum amount of permanent space per AMP that has been used by the database since the last time the DBC.ClearPeakDisk macro was run. Table level metric tagged by `td_table` and `td_database`.*Shown as byte*                                                                        |
| **teradata.disk\_space.peak\_perm.total**(gauge)           | Maximum amount of permanent space per AMP that has been used by the database since the last time the DBC.ClearPeakDisk macro was run. Database level metric tagged by `td_database`.*Shown as byte*                                                                                    |
| **teradata.disk\_space.peak\_persist\_spool**(gauge)       | Maximum persistent spool space, in bytes, that was used at any one time by the database on a specified AMP. Table level metric tagged by `td_table` and `td_database`.*Shown as byte*                                                                                                  |
| **teradata.disk\_space.peak\_persist\_spool.total**(gauge) | Maximum persistent spool space, in bytes, that was used at any one time by the database on a specified AMP. Database level metric tagged by `td_database`.*Shown as byte*                                                                                                              |
| **teradata.disk\_space.peak\_spool**(gauge)                | Maximum spool space, in bytes, that was used at any one time by the database on a specified AMP. Table level metric tagged by `td_table` and `td_database`.*Shown as byte*                                                                                                             |
| **teradata.disk\_space.peak\_spool.total**(gauge)          | Maximum spool space, in bytes, that was used at any one time by the database on a specified AMP. Database level metric tagged by `td_database`.*Shown as byte*                                                                                                                         |
| **teradata.disk\_space.peak\_temp**(gauge)                 | Peak number of bytes used at one time by a temporary table per vproc. Table level metric tagged by `td_table` and `td_database`.*Shown as byte*                                                                                                                                        |
| **teradata.disk\_space.peak\_temp.total**(gauge)           | Peak number of bytes used at one time by a temporary table per vproc. Database level metric tagged by `td_database`.*Shown as byte*                                                                                                                                                    |
| **teradata.disk\_space.perm\_skew**(gauge)                 | Permissible skew limit percent for permanent space usage at the AMP level. Table level metric tagged by `td_table` and `td_database`.                                                                                                                                                  |
| **teradata.disk\_space.perm\_skew.total**(gauge)           | Permissible skew limit percent for permanent space usage at the AMP level. Database level metric tagged by `td_database`.                                                                                                                                                              |
| **teradata.disk\_space.spool\_skew**(gauge)                | Permissible skew limit percent for spool space usage at the AMP level. Table level metric tagged by `td_table` and `td_database`.                                                                                                                                                      |
| **teradata.disk\_space.spool\_skew.total**(gauge)          | Permissible skew limit percent for spool space usage at the AMP level. Database level metric tagged by `td_database`.                                                                                                                                                                  |
| **teradata.disk\_space.temp\_skew**(gauge)                 | Permissible skew limit percent for temporary space usage at the AMP level. Table level metric tagged by `td_table` and `td_database`.                                                                                                                                                  |
| **teradata.disk\_space.temp\_skew.total**(gauge)           | Permissible skew limit percent for temporary space usage at the AMP level. Database level metric tagged by `td_database`.                                                                                                                                                              |
| **teradata.file\_lock.blocks**(gauge)                      | Number of lock requests that were blocked                                                                                                                                                                                                                                              |
| **teradata.file\_lock.deadlocks**(gauge)                   | Number of deadlocks detected on lock requests                                                                                                                                                                                                                                          |
| **teradata.file\_lock.enters**(gauge)                      | Number of times a lock was requested                                                                                                                                                                                                                                                   |
| **teradata.io.throttle\_count**(gauge)                     | Number of times an I/O was throttled                                                                                                                                                                                                                                                   |
| **teradata.io.throttle\_time**(gauge)                      | Total I/O Throttle Time in milliseconds*Shown as millisecond*                                                                                                                                                                                                                          |
| **teradata.io.throttle\_time\_max**(gauge)                 | Maximum I/O Throttle Time in milliseconds*Shown as millisecond*                                                                                                                                                                                                                        |
| **teradata.mem.ctxt\_page\_reads**(gauge)                  | Number of pages swapped in*Shown as page*                                                                                                                                                                                                                                              |
| **teradata.mem.ctxt\_page\_writes**(gauge)                 | Number of pages swapped out*Shown as page*                                                                                                                                                                                                                                             |
| **teradata.mem.fsg.cache\_size**(gauge)                    | Allocated memory for FSG cache. This includes the memory allocated for TIM (VHCacheKB)*Shown as kilobyte*                                                                                                                                                                              |
| **teradata.mem.kernel\_inuse\_size**(gauge)                | Amount of Kernel memory in use by PDE in kilobytes*Shown as kilobyte*                                                                                                                                                                                                                  |
| **teradata.mem.page\_faults\_major**(gauge)                | Number of major page faults. If the page is not loaded in memory at the time the fault is generated, then it is called a major or hard page fault*Shown as page*                                                                                                                       |
| **teradata.mem.page\_faults\_minor**(gauge)                | Number of minor page faults. If the page is loaded in memory at the time the fault is generated, but is not marked in the memory management unit as being loaded in memory, then it is called a minor or soft page fault.*Shown as page*                                               |
| **teradata.mem.seg\_cache\_size**(gauge)                   | Current MB of segment cache*Shown as megabyte*                                                                                                                                                                                                                                         |
| **teradata.mem.seg\_in\_use\_size**(gauge)                 | Current MB of PDE segment files in use*Shown as megabyte*                                                                                                                                                                                                                              |
| **teradata.mem.seg\_max\_avail\_size**(gauge)              | Current MB of maximum PDE segment files available*Shown as megabyte*                                                                                                                                                                                                                   |
| **teradata.mem.seg\_mdl.alloc**(gauge)                     | Number of segments of all sizes allocated for the MDL pool during this period                                                                                                                                                                                                          |
| **teradata.mem.seg\_mdl.alloc\_size**(gauge)               | KB of segments of all sizes allocated for the MDL pool during this period*Shown as kilobyte*                                                                                                                                                                                           |
| **teradata.mem.seg\_mdl.free**(gauge)                      | Number of dirty segments of all sizes freed from the MDL pool during this period                                                                                                                                                                                                       |
| **teradata.mem.seg\_mdl.free\_size**(gauge)                | KB of dirty segments of all sizes freed from the MDL pool during this period*Shown as kilobyte*                                                                                                                                                                                        |
| **teradata.mem.seg\_mdl.inuse\_size**(gauge)               | Total memory in use by segment MDLs*Shown as kilobyte*                                                                                                                                                                                                                                 |
| **teradata.mem.seg\_mdl.recycle**(gauge)                   | Number of segments of all sizes recycled to the MDL pool during this period                                                                                                                                                                                                            |
| **teradata.mem.seg\_mdl.recycle\_size**(gauge)             | KB of segments of all sizes recycled to the MDL pool during this period*Shown as kilobyte*                                                                                                                                                                                             |
| **teradata.mem.seg\_mdl.release**(gauge)                   | Number of clean segments of all sizes freed from the MDL pool during this period                                                                                                                                                                                                       |
| **teradata.mem.seg\_mdl.release\_size**(gauge)             | KB of clean segments of all sizes freed from the MDL pool during this period*Shown as kilobyte*                                                                                                                                                                                        |
| **teradata.mem.txt\_page\_reads**(gauge)                   | Number of pages paged minus the pages swapped in*Shown as page*                                                                                                                                                                                                                        |
| **teradata.mem.vh\_cache\_size**(gauge)                    | Current size of the VH cache in KB. This field is populated by theFSG subsystem*Shown as kilobyte*                                                                                                                                                                                     |
| **teradata.process.blocked**(gauge)                        | Number of threads blocked waiting for I/O at the current time*Shown as thread*                                                                                                                                                                                                         |
| **teradata.process.cpu\_exec**(gauge)                      | Time in milliseconds CPUs are busy executing user execution code, that is, time spent in a user state on behalf of a process. CPUUExec reports the CPU time not used in the system call, or in the kernel*Shown as millisecond*                                                        |
| **teradata.process.cpu\_idle**(gauge)                      | Time in milliseconds CPUs are idle and not waiting for I/O*Shown as millisecond*                                                                                                                                                                                                       |
| **teradata.process.cpu\_io\_wait**(gauge)                  | Time in milliseconds CPUs are idle and waiting for I/O completion*Shown as millisecond*                                                                                                                                                                                                |
| **teradata.process.cpu\_serv**(gauge)                      | Time in milliseconds CPUs are busy executing user service code, that is, privileged work performing system services on behalf of user execution processes which do not have root access CPUUServ reports if a task executing a step used CPU while in the kernel*Shown as millisecond* |
| **teradata.process.cpu\_throttle**(gauge)                  | Number of times that WM CPU COD throttling was triggered                                                                                                                                                                                                                               |
| **teradata.process.cpu\_throttle\_time**(gauge)            | Time in milliseconds that WM CPU COD throttling was active*Shown as millisecond*                                                                                                                                                                                                       |
| **teradata.process.ready**(gauge)                          | Number of runnable or ready tasks, also called threads, able to execute on CPUs when a CPU becomes available*Shown as thread*                                                                                                                                                          |
| **teradata.process.ready\_max**(gauge)                     | Maximum number of ready tasks, also called threads, able to execute on CPUs when a CPU becomes available*Shown as thread*                                                                                                                                                              |

### Events{% #events %}

The Teradata integration does not include any events.

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

**teradata.can\_connect**

Returns `CRITICAL` if the Agent is unable to connect to and collect metrics from the monitored Teradata instance. Returns `OK` otherwise.

*Statuses: ok, critical*

**teradata.can\_query**

Returns `CRITICAL` if the Agent is unable to query the monitored Teradata instance. Returns `OK` otherwise.

*Statuses: ok, critical*

## Troubleshooting{% #troubleshooting %}

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