---
title: Amazon Neptune
description: >-
  A managed graph database service that simplifies building and running apps
  with highly connected datasets.
breadcrumbs: Docs > Integrations > Amazon Neptune
---

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

# Amazon Neptune
Integration version1.3.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 %}

Amazon Neptune is a fast, reliable, fully managed graph database service that makes it easy to build and run applications that work with highly connected datasets.

Enable this integration to see all your Neptune 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 page](https://app.datadoghq.com/integrations/amazon-web-services), ensure that `Neptune` is enabled under the `Metric Collection` tab.
1. Install the [Datadog - Amazon Neptune integration](https://app.datadoghq.com/integrations/amazon-neptune).

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

#### Enable logging{% #enable-logging %}

Configure Amazon Neptune to send logs either to a S3 bucket or to CloudWatch.

**Note**: If you log to a S3 bucket, make sure that `amazon_neptune` is set as *Target prefix*.

#### Send logs to Datadog{% #send-logs-to-datadog %}

1. If you haven't already, set up the [Datadog Forwarder Lambda function](https://docs.datadoghq.com/logs/guide/forwarder.md).

1. Once the Lambda function is installed, manually add a trigger on the S3 bucket or CloudWatch log group that contains your Amazon Neptune logs in the AWS console:

   - [Add a manual trigger on the S3 bucket](https://docs.datadoghq.com/logs/guide/send-aws-services-logs-with-the-datadog-lambda-function.md#collecting-logs-from-s3-buckets)
   - [Add a manual trigger on the CloudWatch Log Group](https://docs.datadoghq.com/logs/guide/send-aws-services-logs-with-the-datadog-lambda-function.md#collecting-logs-from-cloudwatch-log-group)

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

### Metrics{% #metrics %}

|  |
|  |
| **aws.neptune.backup_retention_period_storage_used**(gauge)     | The total amount of backup storage, in bytes, used to support the backup retention window of the Neptune DB cluster. Included in the total reported by `aws.neptune.total_backup_storage_billed`.*Shown as byte*                                                                           |
| **aws.neptune.buffer_cache_hit_ratio**(gauge)                    | The percentage of requests that are served by the buffer cache. If the ratio is below 99.9, consider upgrading the instance type to cache more data in memory.*Shown as percent*                                                                                                           |
| **aws.neptune.cluster_replica_lag**(count)                        | For a read replica the amount of lag when replicating updates from the primary instance in milliseconds.*Shown as millisecond*                                                                                                                                                             |
| **aws.neptune.cluster_replica_lag_maximum**(count)               | The maximum amount of lag between the primary instance and each Neptune DB instance in the DB cluster in milliseconds.*Shown as millisecond*                                                                                                                                               |
| **aws.neptune.cluster_replica_lag_minimum**(count)               | The minimum amount of lag between the primary instance and each Neptune DB instance in the DB cluster in milliseconds.*Shown as millisecond*                                                                                                                                               |
| **aws.neptune.cpu_credit_balance**(gauge)                         | The number of CPU credits that an instance has accumulated, reported at 5-minute intervals.                                                                                                                                                                                                |
| **aws.neptune.cpu_credit_usage**(count)                           | The number of CPU credits consumed during the reporting interval, which is 5 minutes. It measures the time during which physical CPUs have been used for processing instructions by virtual CPUs allocated to the DB instance.                                                             |
| **aws.neptune.cpu_surplus_credit_balance**(gauge)                | The number of surplus credits that have been spent by an unlimited instance when its `aws.neptune.cpu_credit_balance` value is zero. The value is paid down by earned CPU credits.                                                                                                         |
| **aws.neptune.cpu_surplus_credits_charged**(count)               | The number of spent surplus credits that are not paid down by earned CPU credits, and incur an additional charge.                                                                                                                                                                          |
| **aws.neptune.cpuutilization**(count)                               | The percentage of CPU utilization.                                                                                                                                                                                                                                                         |
| **aws.neptune.dfememory_usage_percentage**(gauge)                 | The percentage of memory used by the Neptune DFE query engine.*Shown as percent*                                                                                                                                                                                                           |
| **aws.neptune.ebs_byte_balance**(gauge)                           | The percentage of throughput credits remaining in the burst bucket of the DB instance.*Shown as percent*                                                                                                                                                                                   |
| **aws.neptune.ebs_io_balance**(gauge)                             | The percentage of I/O credits remaining in the burst bucket of the DB instance.*Shown as percent*                                                                                                                                                                                          |
| **aws.neptune.engine_uptime**(count)                               | The amount of time that the instance has been running in seconds.*Shown as second*                                                                                                                                                                                                         |
| **aws.neptune.free_ephemeral_storage**(gauge)                     | The amount of available ephemeral NVMe storage.*Shown as byte*                                                                                                                                                                                                                             |
| **aws.neptune.free_local_storage**(count)                         | The amount of storage available for temporary tables and logs in bytes.*Shown as byte*                                                                                                                                                                                                     |
| **aws.neptune.freeable_memory**(count)                             | The amount of available random access memory in bytes.*Shown as byte*                                                                                                                                                                                                                      |
| **aws.neptune.global_db_data_transfer_bytes**(count)            | The number of bytes of redo log data transferred from the primary AWS Region to a secondary AWS Region in a Neptune global database.*Shown as byte*                                                                                                                                        |
| **aws.neptune.global_db_progress_lag**(gauge)                    | The number of milliseconds that a secondary cluster is behind the primary cluster for both user transactions and system transactions.*Shown as millisecond*                                                                                                                                |
| **aws.neptune.global_db_replicated_write_io**(count)            | The number of write I/O operations replicated from the primary AWS Region in the global database to the cluster volume in a secondary AWS Region.*Shown as operation*                                                                                                                      |
| **aws.neptune.global_db_rpo_lag**(gauge)                         | The recovery point objective (RPO) lag of a secondary cluster behind the primary cluster in a Neptune global database, in milliseconds.*Shown as millisecond*                                                                                                                              |
| **aws.neptune.gremlin_client_errors_per_sec**(gauge)            | The number of client-side errors per second in Gremlin traversals.*Shown as error*                                                                                                                                                                                                         |
| **aws.neptune.gremlin_errors**(count)                              | Number of errors in Gremlin traversals.                                                                                                                                                                                                                                                    |
| **aws.neptune.gremlin_requests**(count)                            | Number of requests to Gremlin engine.                                                                                                                                                                                                                                                      |
| **aws.neptune.gremlin_requests_per_sec**(count)                  | Number of requests to Gremlin engine per second.                                                                                                                                                                                                                                           |
| **aws.neptune.gremlin_server_errors_per_sec**(gauge)            | The number of server-side errors per second in Gremlin traversals.*Shown as error*                                                                                                                                                                                                         |
| **aws.neptune.gremlin_web_socket_available_connections**(count) | Number of potential WebSocket connections currently available.                                                                                                                                                                                                                             |
| **aws.neptune.gremlin_web_socket_client_errors**(count)         | Number of WebSocket client errors on the Gremlin endpoint per second.                                                                                                                                                                                                                      |
| **aws.neptune.gremlin_web_socket_open_connections**(gauge)      | The number of open WebSocket connections to Neptune.*Shown as connection*                                                                                                                                                                                                                  |
| **aws.neptune.gremlin_web_socket_server_errors**(count)         | Number of WebSocket server errors on the Gremlin endpoint per second.                                                                                                                                                                                                                      |
| **aws.neptune.gremlin_web_socket_success**(count)                | Number of successful WebSocket connections to the Gremlin endpoint per second.                                                                                                                                                                                                             |
| **aws.neptune.instance_ebs_iops_exceeded_check**(gauge)         | Reports whether an application attempted to drive IOPS that exceeds the maximum EBS IOPS limits for the instance within the last minute. The value is 0 (IOPS not exceeded) or 1 (IOPS exceeded).                                                                                          |
| **aws.neptune.instance_ebs_throughput_exceeded_check**(gauge)   | Reports whether an application attempted to drive throughput that exceeds the maximum EBS throughput limits for the instance within the last minute. The value is 0 (throughput not exceeded) or 1 (throughput exceeded).                                                                  |
| **aws.neptune.loader_client_errors_per_sec**(gauge)             | The number of client-side errors per second from loader requests.*Shown as error*                                                                                                                                                                                                          |
| **aws.neptune.loader_errors**(count)                               | Number of errors from Loader requests.                                                                                                                                                                                                                                                     |
| **aws.neptune.loader_requests**(count)                             | Number of Loader Requests.                                                                                                                                                                                                                                                                 |
| **aws.neptune.loader_requests_per_sec**(gauge)                   | The number of loader requests per second.*Shown as request*                                                                                                                                                                                                                                |
| **aws.neptune.loader_server_errors_per_sec**(gauge)             | The number of loader server-side errors per second.*Shown as error*                                                                                                                                                                                                                        |
| **aws.neptune.main_request_queue_pending_requests**(gauge)      | The number of requests waiting in the input queue pending execution. Neptune starts throttling requests when they exceed the maximum queue capacity.*Shown as request*                                                                                                                     |
| **aws.neptune.main_request_queue_pending_requests.sum**(gauge)  | The number of requests waiting in the input queue pending execution. Neptune starts throttling requests when they exceed the maximum queue capacity.*Shown as request*                                                                                                                     |
| **aws.neptune.ncuutilization**(gauge)                               | The number of Neptune capacity units (NCUs) in use as a percentage of the maximum NCU capacity set for the cluster. Only applies to Neptune Serverless DB instances and clusters.*Shown as percent*                                                                                        |
| **aws.neptune.network_receive_throughput**(count)                 | The incoming (Receive) network traffic on the DB instance including both customer database traffic and Neptune traffic used for monitoring and replication in bytes/second.                                                                                                                |
| **aws.neptune.network_throughput**(count)                          | The amount of network throughput both received from and transmitted to clients by each instance in the Neptune DB cluster in bytes per second.                                                                                                                                             |
| **aws.neptune.network_transmit_throughput**(count)                | The outgoing (Transmit) network traffic on the DB instance including both customer database traffic and Neptune traffic used for monitoring and replication in bytes/second.                                                                                                               |
| **aws.neptune.num_index_deletes_per_sec**(gauge)                | The number of deletes from individual indexes per second. Deletes from each index are counted individually, including deletes that may get rolled back if a query encounters an error.*Shown as operation*                                                                                 |
| **aws.neptune.num_index_inserts_per_sec**(gauge)                | The number of inserts to individual indexes per second. Inserts to each index are counted separately, including inserts that may get rolled back if a query encounters an error.*Shown as operation*                                                                                       |
| **aws.neptune.num_index_reads_per_sec**(gauge)                  | The number of statements scanned from any index per second. An increase in this metric can cause an increase in query latencies or CPU utilization.*Shown as operation*                                                                                                                    |
| **aws.neptune.num_result_cache_hit**(count)                      | The number of Gremlin result cache hits.*Shown as hit*                                                                                                                                                                                                                                     |
| **aws.neptune.num_result_cache_miss**(count)                     | The number of Gremlin result cache misses.*Shown as miss*                                                                                                                                                                                                                                  |
| **aws.neptune.num_tx_committed**(gauge)                           | The number of transactions successfully committed per second.*Shown as transaction*                                                                                                                                                                                                        |
| **aws.neptune.num_tx_opened**(gauge)                              | The number of transactions opened on the server per second.*Shown as transaction*                                                                                                                                                                                                          |
| **aws.neptune.num_tx_rolled_back**(gauge)                        | For write queries, the number of transactions per second rolled back on the server because of errors. For read-only queries, this metric is equal to the number of completed read-only transactions per second.*Shown as transaction*                                                      |
| **aws.neptune.num_undo_pages_purged**(count)                     | The number of undo page batches purged, which indicates purge progress. Only applies to the writer instance, so the value is 0 for reader instances.                                                                                                                                       |
| **aws.neptune.open_cypher_bolt_open_connections**(gauge)        | The number of open Bolt connections to Neptune.*Shown as connection*                                                                                                                                                                                                                       |
| **aws.neptune.open_cypher_requests_per_sec**(gauge)             | The number of requests per second (both HTTPS and Bolt) to the openCypher engine.*Shown as request*                                                                                                                                                                                        |
| **aws.neptune.read_iops_ephemeral_storage**(gauge)               | The average number of disk read I/O operations to ephemeral NVMe storage.*Shown as operation*                                                                                                                                                                                              |
| **aws.neptune.read_latency_ephemeral_storage**(gauge)            | The average amount of time taken per disk read I/O operation for ephemeral NVMe storage.*Shown as second*                                                                                                                                                                                  |
| **aws.neptune.read_throughput_ephemeral_storage**(gauge)         | The average number of bytes read from disk per second for ephemeral NVMe storage.*Shown as byte*                                                                                                                                                                                           |
| **aws.neptune.result_cache_item_count**(gauge)                   | The number of items in the Gremlin result cache.*Shown as item*                                                                                                                                                                                                                            |
| **aws.neptune.result_cache_oldest_item_timestamp**(gauge)       | The timestamp of the oldest item cached in the Gremlin result cache.                                                                                                                                                                                                                       |
| **aws.neptune.result_cache_size_in_bytes**(gauge)               | The total estimated size, in bytes, of all cached items in the Gremlin result cache.*Shown as byte*                                                                                                                                                                                        |
| **aws.neptune.serverless_database_capacity**(gauge)               | As an instance-level metric, the current instance capacity of a Neptune Serverless instance, in Neptune capacity units (NCUs). At cluster level, the average of the values of the DB instances in the cluster. One NCU consists of 2 GiB of memory with associated vCPU and networking.    |
| **aws.neptune.snapshot_storage_used**(gauge)                      | The total amount of backup storage, in bytes, consumed by all snapshots for a Neptune DB cluster outside its backup retention window. Included in the total reported by `aws.neptune.total_backup_storage_billed`.*Shown as byte*                                                          |
| **aws.neptune.sparql_client_errors_per_sec**(gauge)             | The number of client-side errors per second in SPARQL queries.*Shown as error*                                                                                                                                                                                                             |
| **aws.neptune.sparql_errors**(count)                               | Number of errors in the SPARQL queries.                                                                                                                                                                                                                                                    |
| **aws.neptune.sparql_requests**(count)                             | Number of requests to the SPARQL engine.                                                                                                                                                                                                                                                   |
| **aws.neptune.sparql_requests_per_sec**(count)                   | Number of requests to the SPARQL engine per second.                                                                                                                                                                                                                                        |
| **aws.neptune.sparql_server_errors_per_sec**(gauge)             | The number of SPARQL server errors per second.*Shown as error*                                                                                                                                                                                                                             |
| **aws.neptune.stats_num_statements_scanned**(gauge)              | The total number of statements scanned for DFE statistics since the server started. It only increases while a statistics computation is running.*Shown as operation*                                                                                                                       |
| **aws.neptune.status_errors**(count)                               | Number of errors from the status endpoint.                                                                                                                                                                                                                                                 |
| **aws.neptune.status_requests**(count)                             | Number of requests to the status endpoint.                                                                                                                                                                                                                                                 |
| **aws.neptune.storage_network_receive_throughput**(gauge)        | The amount of network throughput received from the storage subsystem by each instance in the Neptune DB cluster.*Shown as byte*                                                                                                                                                            |
| **aws.neptune.storage_network_throughput**(gauge)                 | The amount of network throughput received from and sent to the storage subsystem by each instance in the Neptune DB cluster.*Shown as byte*                                                                                                                                                |
| **aws.neptune.storage_network_transmit_throughput**(gauge)       | The amount of network throughput sent to the storage subsystem by each instance in the Neptune DB cluster.*Shown as byte*                                                                                                                                                                  |
| **aws.neptune.swap_usage**(gauge)                                  | The amount of swap space used.*Shown as byte*                                                                                                                                                                                                                                              |
| **aws.neptune.temp_storage_iops**(gauge)                          | The number of read and write I/O operations per second on local storage attached to the Neptune DB instance.*Shown as operation*                                                                                                                                                           |
| **aws.neptune.temp_storage_throughput**(gauge)                    | The amount of data transferred to and from local storage associated with the Neptune DB instance, measured once per second.*Shown as byte*                                                                                                                                                 |
| **aws.neptune.total_backup_storage_billed**(gauge)               | The total amount of backup storage, in bytes, for which you are billed for a given Neptune DB cluster. Includes the backup storage measured by `aws.neptune.backup_retention_period_storage_used` and `aws.neptune.snapshot_storage_used`.*Shown as byte*                                  |
| **aws.neptune.total_client_errors_per_sec**(gauge)              | The total number per second of requests that errored out because of client-side issues.*Shown as error*                                                                                                                                                                                    |
| **aws.neptune.total_requests_per_sec**(gauge)                    | The total number of requests per second to the server from all sources.*Shown as request*                                                                                                                                                                                                  |
| **aws.neptune.total_server_errors_per_sec**(gauge)              | The total number per second of requests that errored out on the server because of internal failures.*Shown as error*                                                                                                                                                                       |
| **aws.neptune.undo_log_list_size**(gauge)                        | The count of undo logs in the undo log list. Undo logs contain records of committed transactions that expire when all active transactions are more recent than the commit time. If the value is high and growing, upgrade the writer instance to increase the purge rate.                  |
| **aws.neptune.volume_bytes_left_total**(gauge)                   | The remaining available space for the cluster volume, in bytes. As the cluster volume grows, this value decreases. If it reaches zero, the cluster reports an out-of-space error. Reported only by the writer instance, so use the cluster-level `dbclusteridentifier` tag.*Shown as byte* |
| **aws.neptune.volume_bytes_used**(count)                          | The amount of storage used by your Neptune DB instance in bytes.*Shown as byte*                                                                                                                                                                                                            |
| **aws.neptune.volume_read_iops**(count)                           | The average number of billed read I/O operations from a cluster volume reported at 5-minute intervals.                                                                                                                                                                                     |
| **aws.neptune.volume_write_iops**(count)                          | The average number of write disk I/O operations to the cluster volume reported at 5-minute intervals.                                                                                                                                                                                      |
| **aws.neptune.write_iops_ephemeral_storage**(gauge)              | The average number of disk write I/O operations to ephemeral NVMe storage.*Shown as operation*                                                                                                                                                                                             |
| **aws.neptune.write_latency_ephemeral_storage**(gauge)           | The average amount of time taken per disk write I/O operation for ephemeral NVMe storage.*Shown as second*                                                                                                                                                                                 |
| **aws.neptune.write_throughput_ephemeral_storage**(gauge)        | The average number of bytes written to disk per second for ephemeral NVMe storage.*Shown as byte*                                                                                                                                                                                          |
| **aws.neptune.graph_size_bytes**(gauge)                           | Aggregated storage volume used for graph indexes, dictionary, and vector indexes.*Shown as byte*                                                                                                                                                                                           |
| **aws.neptune.graph_storage_usage_percent**(gauge)               | The percentage of the graph's storage capacity currently in use.*Shown as percent*                                                                                                                                                                                                         |
| **aws.neptune.num_edge_properties**(gauge)                        | Number of properties across all edges in the graph.                                                                                                                                                                                                                                        |
| **aws.neptune.num_edges**(gauge)                                   | Number of edges in the graph.                                                                                                                                                                                                                                                              |
| **aws.neptune.num_open_cypher_client_errors_per_sec**(rate)   | Number of openCypher requests per second resulting in client-side failures (4xx errors).*Shown as request*                                                                                                                                                                                 |
| **aws.neptune.num_open_cypher_requests_per_sec**(rate)         | Number of openCypher requests per second made to the server.*Shown as request*                                                                                                                                                                                                             |
| **aws.neptune.num_open_cypher_server_errors_per_sec**(rate)   | Number of openCypher requests per second resulting in internal failures (5xx errors).*Shown as request*                                                                                                                                                                                    |
| **aws.neptune.num_queued_requests_per_sec**(rate)               | Number of requests per second accepted by the server and pending execution.*Shown as request*                                                                                                                                                                                              |
| **aws.neptune.num_vectors**(gauge)                                 | Number of vectors present in the Vector Search Index.                                                                                                                                                                                                                                      |
| **aws.neptune.num_vertex_properties**(gauge)                      | Number of properties across all vertices in the graph, including LPG labels, which Neptune Analytics models as vertex properties.                                                                                                                                                          |

### Events{% #events %}

The Amazon Neptune integration does not include any events.

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

The Amazon Neptune integration does not include any service checks.

## Troubleshooting{% #troubleshooting %}

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