---
title: amazon_odb
description: >-
  Oracle Database at AWS runs Oracle Exadata and Autonomous Database services on
  AWS infrastructure.
breadcrumbs: Docs > Integrations > amazon_odb
---

> For the complete documentation index, see [llms.txt](https://docs.datadoghq.com/llms.txt).

# amazon_odb
Integration version1.0.0
{% callout %}
# Important note for users on the following Datadog sites: us2.ddog-gov.com

{% alert level="info" %}
To find out if this integration is available in your organization, see your [Datadog Integrations](https://app.datadoghq.com/integrations) page or ask your organization administrator.

To initiate an exception request to enable this integration for your organization, email [support@ddog-gov.com](mailto:support@ddog-gov.com).
{% /alert %}

{% /callout %}

## Overview{% #overview %}

Oracle Database at AWS runs Oracle Exadata and Autonomous Database services on AWS infrastructure.

Enable this integration to see all your Oracle Database at AWS metrics in Datadog.

## Setup{% #setup %}

### Installation{% #installation %}

If you haven't already, set up the [Amazon Web Services integration](https://docs.datadoghq.com/integrations/amazon_web_services.md) first.

### Metric collection{% #metric-collection %}

1. In the [AWS integration tile](https://app.datadoghq.com/integrations/amazon-web-services), ensure that `ODB` is enabled under the `Metric Collection` tab.
1. Install the [Datadog - Oracle Database at AWS integration](https://app.datadoghq.com/integrations/amazon-odb).

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

### Metrics{% #metrics %}

|  |
|  |
| **aws.odb.apex_apps**(gauge)                                   | The number of active APEX applications.                                                                                                                                                                                                        |
| **aws.odb.apex_page_events**(count)                           | The number of APEX page events.*Shown as event*                                                                                                                                                                                                |
| **aws.odb.apex_page_load_time**(gauge)                       | APEX page load time.*Shown as second*                                                                                                                                                                                                          |
| **aws.odb.apex_workspace_count**(gauge)                       | The number of APEX workspaces.                                                                                                                                                                                                                 |
| **aws.odb.apply_lag**(gauge)                                   | The number of seconds the standby database is behind the primary database.*Shown as second*                                                                                                                                                    |
| **aws.odb.asm_diskgroup_utilization**(gauge)                  | The percentage of usable space used in an ASM disk group.*Shown as percent*                                                                                                                                                                    |
| **aws.odb.asm_diskgroup_utilization.maximum**(gauge)          | The maximum percentage of usable space used in an ASM disk group.*Shown as percent*                                                                                                                                                            |
| **aws.odb.average_active_sessions**(gauge)                    | The average number of sessions actively executing or waiting for resources.*Shown as session*                                                                                                                                                  |
| **aws.odb.block_changes**(gauge)                               | The average number of blocks changed per second.*Shown as block*                                                                                                                                                                               |
| **aws.odb.blocking_sessions**(gauge)                           | The number of sessions that have been blocking other sessions for more than 60 seconds.*Shown as session*                                                                                                                                      |
| **aws.odb.connections_dropped_by_client**(count)             | The number of connections dropped by the client.*Shown as connection*                                                                                                                                                                          |
| **aws.odb.connections_dropped_by_server**(count)             | The number of connections dropped by the server.*Shown as connection*                                                                                                                                                                          |
| **aws.odb.cpu_time**(gauge)                                    | The average rate of accumulation of CPU time by foreground sessions in the database instance, in seconds per second.*Shown as fraction*                                                                                                        |
| **aws.odb.cpu_utilization**(gauge)                             | CPU utilization as a percentage.*Shown as percent*                                                                                                                                                                                             |
| **aws.odb.cpu_utilization.maximum**(gauge)                     | Maximum CPU utilization as a percentage.*Shown as percent*                                                                                                                                                                                     |
| **aws.odb.current_logons**(count)                              | The number of successful logons during the selected interval.*Shown as connection*                                                                                                                                                             |
| **aws.odb.data_loss_exposure**(gauge)                         | The time since the last valid backup, indicating potential data loss exposure.*Shown as second*                                                                                                                                                |
| **aws.odb.database_availability**(gauge)                       | The indicator of whether the database is available for connections (1=available, 0=unavailable).                                                                                                                                               |
| **aws.odb.db_block_changes**(gauge)                           | The number of changes that were part of an update or delete operation made to blocks in the SGA.*Shown as block*                                                                                                                               |
| **aws.odb.db_time**(gauge)                                     | The average rate of accumulation of database time (CPU time plus wait time) by user sessions, in seconds per second.*Shown as fraction*                                                                                                        |
| **aws.odb.ecpus_allocated**(gauge)                             | The actual number of ECPUs allocated by the service during the selected interval.                                                                                                                                                              |
| **aws.odb.execute_count**(count)                               | The number of user and recursive calls that executed SQL statements during the selected interval.*Shown as execution*                                                                                                                          |
| **aws.odb.failed_connections**(count)                          | The total number of failed connections to the database during the selected interval. A connection is counted as failed when a connection attempt reaches the database and logs errors ORA-12514, ORA-12519, or ORA-12529.*Shown as connection* |
| **aws.odb.failed_logons**(count)                               | The number of logons that failed because of an invalid user name and/or password during the selected interval.*Shown as connection*                                                                                                            |
| **aws.odb.filesystem_utilization**(gauge)                      | The percent utilization of the provisioned filesystem.*Shown as percent*                                                                                                                                                                       |
| **aws.odb.filesystem_utilization.maximum**(gauge)              | The maximum percent utilization of the provisioned filesystem.*Shown as percent*                                                                                                                                                               |
| **aws.odb.hard_parse_count**(count)                           | The number of hard parse calls during the selected time interval.                                                                                                                                                                              |
| **aws.odb.io_throughput**(gauge)                               | The average IO throughput in megabytes per second.*Shown as mebibyte*                                                                                                                                                                          |
| **aws.odb.iops**(gauge)                                         | The average number of input-output operations per second.*Shown as operation*                                                                                                                                                                  |
| **aws.odb.load_average**(gauge)                                | The system load average measured over 5 minutes.                                                                                                                                                                                               |
| **aws.odb.logical_blocks_read**(gauge)                        | The average number of blocks read from SGA/Memory (buffer cache) per second.*Shown as read*                                                                                                                                                    |
| **aws.odb.logical_reads**(count)                               | The sum of db block gets plus consistent gets during the selected time interval.*Shown as read*                                                                                                                                                |
| **aws.odb.memory_utilization**(gauge)                          | The percentage of memory available for starting new applications without swapping.*Shown as percent*                                                                                                                                           |
| **aws.odb.memory_utilization.maximum**(gauge)                  | The maximum percentage of memory available for starting new applications without swapping.*Shown as percent*                                                                                                                                   |
| **aws.odb.node_status**(gauge)                                 | The indicator of whether the host is reachable.                                                                                                                                                                                                |
| **aws.odb.ocpus_allocated**(gauge)                             | The number of OCPUs allocated.                                                                                                                                                                                                                 |
| **aws.odb.parse_count**(count)                                 | The number of hard and soft parses during the selected interval.                                                                                                                                                                               |
| **aws.odb.parse_failure_count**(count)                        | The number of parse failures during the selected time interval.                                                                                                                                                                                |
| **aws.odb.parses_by_type**(gauge)                             | The number of hard or soft parses per second.                                                                                                                                                                                                  |
| **aws.odb.peer_lag**(gauge)                                    | The total time by which the disaster recovery peer lags behind its primary database.*Shown as second*                                                                                                                                          |
| **aws.odb.physical_read_total_bytes**(count)                 | The size in bytes of disk reads by all database instance activity, including application reads, backup and recovery, and other utilities.*Shown as byte*                                                                                       |
| **aws.odb.physical_reads**(count)                              | The number of data blocks read from disk during the selected time interval.*Shown as read*                                                                                                                                                     |
| **aws.odb.physical_write_total_bytes**(count)                | The size in bytes of all disk writes for the database instance, including application activity, backup and recovery, and other utilities.*Shown as byte*                                                                                       |
| **aws.odb.physical_writes**(count)                             | The number of data blocks written to disk during the selected time interval.*Shown as write*                                                                                                                                                   |
| **aws.odb.protected_database_health**(gauge)                  | The protection health status of the database (0=protected, 1=warning, 2=alert).                                                                                                                                                                |
| **aws.odb.protected_database_size**(gauge)                    | The total storage space consumed by a database protected by Recovery Service.*Shown as gibibyte*                                                                                                                                               |
| **aws.odb.query_latency**(gauge)                               | The time taken to display the results of a simple query on the user's screen.*Shown as millisecond*                                                                                                                                            |
| **aws.odb.queued_statements**(count)                           | The number of queued SQL statements aggregated across all consumer groups during the selected interval.                                                                                                                                        |
| **aws.odb.redo_generated**(count)                              | The amount of redo generated in bytes during the selected time interval.*Shown as byte*                                                                                                                                                        |
| **aws.odb.redo_size**(gauge)                                   | The average amount of redo generated per second.*Shown as mebibyte*                                                                                                                                                                            |
| **aws.odb.running_statements**(count)                          | The number of running SQL statements aggregated across all consumer groups during the selected interval.                                                                                                                                       |
| **aws.odb.session_utilization**(gauge)                         | The session utilization as a percentage aggregated across all consumer groups.*Shown as percent*                                                                                                                                               |
| **aws.odb.session_utilization.maximum**(gauge)                 | The maximum session utilization as a percentage aggregated across all consumer groups.*Shown as percent*                                                                                                                                       |
| **aws.odb.sessions**(gauge)                                     | The number of sessions in the database.*Shown as session*                                                                                                                                                                                      |
| **aws.odb.sessions.maximum**(gauge)                             | The maximum number of sessions in the database.*Shown as session*                                                                                                                                                                              |
| **aws.odb.sessions.minimum**(gauge)                             | The minimum number of sessions in the database.*Shown as session*                                                                                                                                                                              |
| **aws.odb.space_used_for_recovery_window**(gauge)           | The amount of storage space currently used to meet the recovery window goal for the protected database.*Shown as gibibyte*                                                                                                                     |
| **aws.odb.sqlnet_bytes_from_client**(count)                  | The number of bytes received from the client over Oracle Net Services during the selected time interval.*Shown as byte*                                                                                                                        |
| **aws.odb.sqlnet_bytes_from_dblink**(count)                  | The number of bytes received from a database link over Oracle Net Services during the selected time interval.*Shown as byte*                                                                                                                   |
| **aws.odb.sqlnet_bytes_to_client**(count)                    | The number of bytes sent to the client from foreground processes during the selected time interval.*Shown as byte*                                                                                                                             |
| **aws.odb.sqlnet_bytes_to_dblink**(count)                    | The number of bytes sent over a database link during the selected time interval.*Shown as byte*                                                                                                                                                |
| **aws.odb.storage_allocated**(gauge)                           | The total amount of storage space allocated to the database.*Shown as gibibyte*                                                                                                                                                                |
| **aws.odb.storage_allocated_by_tablespace**(gauge)           | The total amount of storage space allocated to the tablespace. For container databases, this metric provides data for root container tablespaces.*Shown as gibibyte*                                                                           |
| **aws.odb.storage_max**(gauge)                                 | The maximum amount of storage reserved for the database during the interval.*Shown as gibibyte*                                                                                                                                                |
| **aws.odb.storage_used**(gauge)                                | The total amount of storage space used by the database.*Shown as gibibyte*                                                                                                                                                                     |
| **aws.odb.storage_used_by_tablespace**(gauge)                | The total amount of storage space used by the tablespace. For container databases, this metric provides data for root container tablespaces.*Shown as gibibyte*                                                                                |
| **aws.odb.storage_utilization**(gauge)                         | The percentage of provisioned storage capacity currently in use across all tablespaces.*Shown as percent*                                                                                                                                      |
| **aws.odb.storage_utilization.maximum**(gauge)                 | The maximum percentage of provisioned storage capacity currently in use across all tablespaces.*Shown as percent*                                                                                                                              |
| **aws.odb.storage_utilization_by_tablespace**(gauge)         | The percentage of storage space utilized by the tablespace. For container databases, this metric provides data for root container tablespaces.*Shown as percent*                                                                               |
| **aws.odb.storage_utilization_by_tablespace.maximum**(gauge) | The maximum percentage of storage space utilized by the tablespace. For container databases, this metric provides data for root container tablespaces.*Shown as percent*                                                                       |
| **aws.odb.swap_utilization**(gauge)                            | The percent utilization of total swap space.*Shown as percent*                                                                                                                                                                                 |
| **aws.odb.swap_utilization.maximum**(gauge)                    | The maximum percent utilization of total swap space.*Shown as percent*                                                                                                                                                                         |
| **aws.odb.transaction_count**(count)                           | The combined number of user commits and user rollbacks during the selected interval.*Shown as transaction*                                                                                                                                     |
| **aws.odb.transactions_by_status**(gauge)                     | The number of committed or rolled back transactions per second.*Shown as transaction*                                                                                                                                                          |
| **aws.odb.transport_lag**(gauge)                               | The number of seconds of redo not yet available on the standby database.*Shown as second*                                                                                                                                                      |
| **aws.odb.user_calls**(count)                                  | The combined number of logons, parses, and execute calls during the selected interval.                                                                                                                                                         |
| **aws.odb.user_commits**(count)                                | The number of user commits during the selected time interval.*Shown as transaction*                                                                                                                                                            |
| **aws.odb.user_rollbacks**(count)                              | The number of times users manually issue the ROLLBACK statement or an error occurs during a user's transactions during the selected time interval.*Shown as transaction*                                                                       |
| **aws.odb.wait_time**(gauge)                                   | The average rate of accumulation of non-idle wait time by foreground sessions in the database instance, in seconds per second.*Shown as fraction*                                                                                              |

### Events{% #events %}

The Oracle Database at AWS integration does not include any events.

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

The Oracle Database at AWS integration does not include any service checks.

## Troubleshooting{% #troubleshooting %}

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