---
title: OCI Autonomous AI Database
description: >-
  Oracle Autonomous AI Database automates database management with self-tuning,
  patching, and scaling.
breadcrumbs: Docs > Integrations > OCI Autonomous AI Database
---

# OCI Autonomous AI Database
Integration version1.0.0
## Overview{% #overview %}

Oracle Autonomous Database automatically translates natural language into database queries and allows you to use SQL, JSON documents, Oracle Graph, Oracle Spatial, text, and vectors in a single database.

This integration allows you to monitor and alert on the current connections, statement count, CPU utilization, and backup time of your Autonomous Database by collecting metrics and tags from the [oci_autonomous_database](https://docs.oracle.com/en-us/iaas/autonomous-database/doc/monitor-databases-autonomous-database-metrics.html) namespace.

Installing the [Datadog Agent](https://docs.datadoghq.com/integrations/oracle) on your Oracle Databases provdes real-time insights into additional metrics such as active sessions, disk usage, table space usage, and more.

Enable Datadog's [Database Monitoring (DBM)](https://docs.datadoghq.com/database_monitoring/) for enhanced insights into query performance and database health. In addition to the standard integration features, Datadog DBM provides query-level metrics, live and historical query snapshots, wait event analysis, database load, query explain plans, and blocking query insights.

## Setup{% #setup %}

### Installation{% #installation %}

After you set up the [Oracle Cloud Infrastructure](https://docs.datadoghq.com/integrations/oracle_cloud_infrastructure/) integration, ensure that the `oci_autonomous_database` namespace is included in your [Connector Hub](https://cloud.oracle.com/connector-hub/service-connectors).

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

### Metrics{% #metrics %}

|  |
|  |
| **oci.autonomous\_database.apply\_lag**(gauge)                           | This metric displays (in seconds) how far the standby database is behind the primary database as of the time sampled.*Shown as second*                                                                                                                                                                                                 |
| **oci.autonomous\_database.block\_changes**(gauge)                       | The average number of blocks changed per second.Also available for OCI Autonomous AI Database Serverless as `dbblock_changes`.*Shown as update*                                                                                                                                                                                        |
| **oci.autonomous\_database.cpu\_time**(gauge)                            | Average rate of accumulation of CPU time by foreground sessions in the database over the time interval.Statistic: Mean. Interval: 1 minute.Also available for OCI Autonomous AI Database Serverless.*Shown as second*                                                                                                                  |
| **oci.autonomous\_database.cpu\_utilization**(gauge)                     | The CPU usage expressed as a percentage, aggregated across all consumer groups. The utilization percentage is reported with respect to the number of CPUs the database is allowed to use.Statistic: Mean. Interval: 1 minute.Also available for OCI Autonomous AI Database Serverless.*Shown as percent*                               |
| **oci.autonomous\_database.current\_logons**(count)                      | The number of successful logons during the selected interval.Statistic: Count. Interval: 1 minute.Also available for OCI Autonomous AI Database Serverless.*Shown as operation*                                                                                                                                                        |
| **oci.autonomous\_database.dbtime**(gauge)                               | The amount of time database user sessions spend executing database code (CPU Time + WaitTime). DB Time is used to infer database call latency, because DB Time increases in direct proportion to both database call latency (response time) and call volume.Also available for OCI Autonomous AI Database Serverless.*Shown as second* |
| **oci.autonomous\_database.ecpus\_allocated**(gauge)                     | The actual number of ECPUs allocated by the service during the selected interval of time.*Shown as cpu*                                                                                                                                                                                                                                |
| **oci.autonomous\_database.execute\_count**(count)                       | The number of user and recursive calls that executed SQL statements during the selected interval.Statistic: Sum. Interval: 1 minute.Also available for OCI Autonomous AI Database Serverless.*Shown as execution*                                                                                                                      |
| **oci.autonomous\_database.iops**(gauge)                                 | The average number of I/O operations per second.*Shown as operation*                                                                                                                                                                                                                                                                   |
| **oci.autonomous\_database.iothroughput**(gauge)                         | The average throughput in MB per second.*Shown as megabyte*                                                                                                                                                                                                                                                                            |
| **oci.autonomous\_database.logical\_blocks\_read**(gauge)                | The average number of logical block reads ("db block gets" plus "consistent gets") per second. Includes buffered and direct I/O. Statistic: Sum. Interval: 1 minute*Shown as read*                                                                                                                                                     |
| **oci.autonomous\_database.ocpus\_allocated**(gauge)                     | The actual number of OCPUs allocated by the service during the selected interval of time.*Shown as cpu*                                                                                                                                                                                                                                |
| **oci.autonomous\_database.parse\_count**(count)                         | The number of hard and soft parses during the selected interval.Statistic: Sum. Interval: 1 minute.Also available for OCI Autonomous AI Database Serverless.*Shown as event*                                                                                                                                                           |
| **oci.autonomous\_database.parses\_by\_type**(count)                     | The number of hard or soft parses per second.*Shown as event*                                                                                                                                                                                                                                                                          |
| **oci.autonomous\_database.queued\_statements**(count)                   | The number of queued SQL statements, aggregated across all consumer groups, during the selected interval.Statistic: Sum. Interval: 1 minute.Also available for OCI Autonomous AI Database Serverless.*Shown as execution*                                                                                                              |
| **oci.autonomous\_database.redo\_size**(gauge)                           | The average amount of redo generated in MB per second.*Shown as megabyte*                                                                                                                                                                                                                                                              |
| **oci.autonomous\_database.running\_statements**(count)                  | The number of running SQL statements, aggregated across all consumer groups, during the selected interval.Statistic: Mean. Interval: 1 minute.Also available for OCI Autonomous AI Database Serverless.*Shown as execution*                                                                                                            |
| **oci.autonomous\_database.session\_utilization**(gauge)                 | The maximum session utilization expressed as a percentage, aggregated across all consumer groups.Statistic: Mean Interval: 1 minute.Also available for OCI Autonomous AI Database Serverless.*Shown as percent*                                                                                                                        |
| **oci.autonomous\_database.sessions**(count)                             | The number of sessions in the database.Statistic: Sum. Interval: 1 minute.Also available for OCI Autonomous AI Database Serverless.*Shown as session*                                                                                                                                                                                  |
| **oci.autonomous\_database.storage\_allocated**(gauge)                   | Maximum amount of space allocated to the database during the interval.Statistic: Max. Interval: 1 hour.Also available for OCI Autonomous AI Database Serverless.*Shown as gigabyte*                                                                                                                                                    |
| **oci.autonomous\_database.storage\_allocated\_by\_tablespace**(gauge)   | Maximum amount of space allocated for each tablespace during the interval.*Shown as gigabyte*                                                                                                                                                                                                                                          |
| **oci.autonomous\_database.storage\_used**(gauge)                        | Maximum amount of space used during the interval.Statistic: Max. Interval: 1 hour.Also available for OCI Autonomous AI Database Serverless.*Shown as gigabyte*                                                                                                                                                                         |
| **oci.autonomous\_database.storage\_used\_by\_tablespace**(gauge)        | Maximum amount of space used by each tablespace during the interval.*Shown as gigabyte*                                                                                                                                                                                                                                                |
| **oci.autonomous\_database.storage\_utilization**(gauge)                 | The percentage of provisioned storage capacity currently in use. Represents the total allocated space for all tablespaces.Statistic: Mean. Interval: 1 hour.Also available for OCI Autonomous AI Database Serverless.*Shown as percent*                                                                                                |
| **oci.autonomous\_database.storage\_utilization\_by\_tablespace**(gauge) | The percentage of space utilized by each tablespace.*Shown as percent*                                                                                                                                                                                                                                                                 |
| **oci.autonomous\_database.transaction\_count**(count)                   | The combined number of user commits and user rollbacks during the selected interval.Statistic: Sum. Interval: 1 minute.Also available for OCI Autonomous AI Database Serverless.*Shown as event*                                                                                                                                       |
| **oci.autonomous\_database.transactions\_by\_status**(count)             | The number of committed or rolled back transactions per second.*Shown as transaction*                                                                                                                                                                                                                                                  |
| **oci.autonomous\_database.transport\_lag**(gauge)                       | The approximate number of seconds of redo not yet available on the standby database as of the time sampled.*Shown as second*                                                                                                                                                                                                           |
| **oci.autonomous\_database.user\_calls**(count)                          | The combined number of logons, parses, and execute calls during the selected interval.Statistic: Sum. Interval: 1 minute.Also available for OCI Autonomous AI Database Serverless.*Shown as event*                                                                                                                                     |
| **oci.autonomous\_database.wait\_time**(gauge)                           | Average rate of accumulation of non-idle wait time by foreground sessions in the database over the time interval.Statistic: Mean. Interval: 1 minute.Also available for OCI Autonomous AI Database Serverless.*Shown as second*                                                                                                        |

#### Oracle Autonomous AI Database Serverless metrics{% #oracle-autonomous-ai-database-serverless-metrics %}

|  |
|  |
| oci.autonomous_database.dbblock_changes(gauge)     | The average number of blocks changed per second.*Shown as update*                                                                                                                                                                                                                                                                                                                                                  |
| oci.autonomous_database.cpu_time(gauge)            | Average rate of accumulation of CPU time by foreground sessions in the database over the time interval.Statistic: Mean. Interval: 1 minute.*Shown as second*                                                                                                                                                                                                                                                       |
| oci.autonomous_database.cpu_utilization(gauge)     | The CPU usage expressed as a percentage, aggregated across all consumer groups. The utilization percentage is reported with respect to the number of CPUs the database is allowed to use.Statistic: Mean. Interval: 1 minute.*Shown as percent*                                                                                                                                                                    |
| oci.autonomous_database.current_logons(count)      | The number of successful logons during the selected interval.Statistic: Count. Interval: 1 minute.*Shown as operation*                                                                                                                                                                                                                                                                                             |
| oci.autonomous_database.dbtime(gauge)              | The amount of time database user sessions spend executing database code (CPU Time + WaitTime). DB Time is used to infer database call latency, because DB Time increases in direct proportion to both database call latency (response time) and call volume. It is calculated as the average rate of accumulation of database time by foreground sessions in the database over the time interval.*Shown as second* |
| oci.autonomous_database.execute_count(count)       | The number of user and recursive calls that executed SQL statements during the selected interval.Statistic: Sum. Interval: 1 minute.*Shown as execution*                                                                                                                                                                                                                                                           |
| oci.autonomous_database.logical_reads(gauge)       | The sum of "db block gets" plus "consistent gets", during the selected time interval. This includes logical reads of database blocks from either the buffer cache or process private memory.*Shown as read*                                                                                                                                                                                                        |
| oci.autonomous_database.parse_count(count)         | The number of hard and soft parses during the selected interval.Statistic: Sum. Interval: 1 minute.*Shown as event*                                                                                                                                                                                                                                                                                                |
| oci.autonomous_database.queued_statements(count)   | The number of queued SQL statements, aggregated across all consumer groups, during the selected interval.Statistic: Sum. Interval: 1 minute.*Shown as execution*                                                                                                                                                                                                                                                   |
| oci.autonomous_database.running_statements(count)  | The number of running SQL statements, aggregated across all consumer groups, during the selected interval.Statistic: Mean. Interval: 1 minute.*Shown as execution*                                                                                                                                                                                                                                                 |
| oci.autonomous_database.session_utilization(gauge) | The maximum session utilization expressed as a percentage, aggregated across all consumer groups.Statistic: Mean Interval: 1 minute.*Shown as percent*                                                                                                                                                                                                                                                             |
| oci.autonomous_database.sessions(count)            | The number of sessions in the database.Statistic: Sum. Interval: 1 minute.*Shown as session*                                                                                                                                                                                                                                                                                                                       |
| oci.autonomous_database.storage_allocated(gauge)   | Maximum amount of space allocated to the database during the interval.Statistic: Max. Interval: 1 hour.*Shown as gigabyte*                                                                                                                                                                                                                                                                                         |
| oci.autonomous_database.storage_used(gauge)        | Maximum amount of space used during the interval.Statistic: Max. Interval: 1 hour.*Shown as gigabyte*                                                                                                                                                                                                                                                                                                              |
| oci.autonomous_database.storage_utilization(gauge) | The percentage of provisioned storage capacity currently in use. Represents the total allocated space for all tablespaces.Statistic: Mean. Interval: 1 hour.*Shown as percent*                                                                                                                                                                                                                                     |
| oci.autonomous_database.transaction_count(count)   | The combined number of user commits and user rollbacks during the selected interval.Statistic: Sum. Interval: 1 minute.*Shown as event*                                                                                                                                                                                                                                                                            |
| oci.autonomous_database.user_calls(count)          | The combined number of logons, parses, and execute calls during the selected interval.Statistic: Sum. Interval: 1 minute.*Shown as event*                                                                                                                                                                                                                                                                          |
| oci.autonomous_database.wait_time(gauge)           | Average rate of accumulation of non-idle wait time by foreground sessions in the database over the time interval.Statistic: Mean. Interval: 1 minute.*Shown as second*                                                                                                                                                                                                                                             |

### Events{% #events %}

The OCI Autonomous Database integration does not include any events.

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

The OCI Autonomous Database integration does not include any service checks.

## Troubleshooting{% #troubleshooting %}

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