---
title: Amazon S3 Storage Lens
description: >-
  Amazon S3 Storage Lens provides a single view of object storage usage and
  activity across your entire Amazon S3 storage.
breadcrumbs: Docs > Integrations > Amazon S3 Storage Lens
---

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

# Amazon S3 Storage Lens
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 %}

{% alert level="info" %}
Enable [Storage Management](https://docs.datadoghq.com/integrations/guide/storage-monitoring-setup.md) to get granular visibility into your buckets and prefixes, enabling you to eliminate unnecessary costs and prevent unexpected spend.
{% /alert %}

## Overview{% #overview %}

Amazon S3 Storage Lens provides a single view of usage and activity across your Amazon S3 storage. You can use S3 Storage Lens to generate summary insights, such as finding out how much storage you have across your entire organization, or which are the fastest growing buckets and prefixes. Identify outliers in your storage metrics, and then drill down to further investigate the source of the spike in usage or activity.

Enable this integration to see all your S3 Storage Lens 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. Enable [CloudWatch publishing for S3 Storage Lens](https://docs.aws.amazon.com/AmazonS3/latest/userguide/storage-lens-cloudwatch-enable-publish-option.html) within your AWS account. You must be using "Advanced metrics and recommendations" to use this feature.
1. In the [AWS integration page](https://app.datadoghq.com/integrations/amazon-web-services), ensure that `S3 Storage Lens` is enabled under the `Metric Collection` tab.
1. Install the [Datadog - Amazon S3 Storage Lens integration](https://app.datadoghq.com/integrations/amazon-s3-storage-lens).

**Note:** S3 Storage Lens metrics are daily metrics and are published to CloudWatch once per day.

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

### Metrics{% #metrics %}

|  |
|  |
| **aws.s3.storagelens.200_ok_status_count**(gauge)                                     | The number of 200 OK status codes.*Shown as response*                                                                                                                                                     |
| **aws.s3.storagelens.206_partial_content_status_count**(gauge)                       | The number of 206 Partial Content status codes.*Shown as response*                                                                                                                                        |
| **aws.s3.storagelens.400_bad_request_error_count**(gauge)                            | The number of 400 Bad Request status codes.*Shown as error*                                                                                                                                               |
| **aws.s3.storagelens.403_forbidden_error_count**(gauge)                               | The number of 403 Forbidden status codes.*Shown as error*                                                                                                                                                 |
| **aws.s3.storagelens.404_not_found_error_count**(gauge)                              | The number of 404 Not Found status codes.*Shown as error*                                                                                                                                                 |
| **aws.s3.storagelens.4xx_errors**(gauge)                                                | The total number of HTTP 4xx errors in scope.*Shown as error*                                                                                                                                             |
| **aws.s3.storagelens.500_internal_server_error_count**(gauge)                        | The number of 500 Internal Server Error status codes.*Shown as error*                                                                                                                                     |
| **aws.s3.storagelens.503_service_unavailable_error_count**(gauge)                    | The number of 503 Service Unavailable status codes.*Shown as error*                                                                                                                                       |
| **aws.s3.storagelens.5xx_errors**(gauge)                                                | The total number of HTTP 5xx server errors in scope.*Shown as error*                                                                                                                                      |
| **aws.s3.storagelens.abort_incomplete_mpu_lifecycle_rule_count**(gauge)             | The number of lifecycle rules to delete incomplete multipart uploads.                                                                                                                                     |
| **aws.s3.storagelens.all_requests**(gauge)                                              | The total number of HTTP requests made.*Shown as request*                                                                                                                                                 |
| **aws.s3.storagelens.all_sse_kms_requests**(gauge)                                    | The total number of requests that specify SSE-KMS.*Shown as request*                                                                                                                                      |
| **aws.s3.storagelens.all_unsupported_signature_requests**(gauge)                      | The total number of requests that use unsupported AWS signature versions.*Shown as request*                                                                                                               |
| **aws.s3.storagelens.all_unsupported_tls_requests**(gauge)                            | The total number of requests that use unsupported Transport Layer Security (TLS) versions.*Shown as request*                                                                                              |
| **aws.s3.storagelens.average_first_byte_latency**(gauge)                              | The average per-request time between when an Amazon S3 bucket receives a complete request and when it starts returning the response, measured over the past 24 hours.*Shown as millisecond*               |
| **aws.s3.storagelens.average_total_request_latency**(gauge)                           | The average elapsed per-request time between the first byte received and the last byte sent to an Amazon S3 bucket, measured over the past 24 hours.*Shown as millisecond*                                |
| **aws.s3.storagelens.bytes_downloaded**(gauge)                                          | The total number bytes downloaded.*Shown as byte*                                                                                                                                                         |
| **aws.s3.storagelens.bytes_uploaded**(gauge)                                            | The total number bytes uploaded.*Shown as byte*                                                                                                                                                           |
| **aws.s3.storagelens.concurrent_put_503_error_count**(gauge)                         | The number of 503 errors that are generated due to concurrent writes to the same object.*Shown as error*                                                                                                  |
| **aws.s3.storagelens.cross_account_replication_rule_count**(gauge)                   | The number of replication rules for cross-account replication.                                                                                                                                            |
| **aws.s3.storagelens.cross_region_replication_rule_count**(gauge)                    | The number of replication rules for Cross-Region Replication (CRR).                                                                                                                                       |
| **aws.s3.storagelens.cross_region_request_count**(gauge)                              | The number of requests that originate from a client in a different Region than the bucket's home Region.*Shown as request*                                                                                |
| **aws.s3.storagelens.cross_region_transferred_bytes**(gauge)                          | The number of bytes that are transferred from calls in a different Region than the bucket's home Region.*Shown as byte*                                                                                   |
| **aws.s3.storagelens.cross_region_without_replication_request_count**(gauge)        | The number of requests that originate from a client in a different Region than the bucket's home Region, excluding cross-Region replication requests.*Shown as request*                                   |
| **aws.s3.storagelens.cross_region_without_replication_transferred_bytes**(gauge)    | The number of bytes that are transferred from calls in a different Region than the bucket's home Region, excluding cross-Region replication bytes.*Shown as byte*                                         |
| **aws.s3.storagelens.current_version_object_count**(gauge)                            | The total number of objects that are current version.*Shown as object*                                                                                                                                    |
| **aws.s3.storagelens.current_version_storage_bytes**(gauge)                           | The total number of bytes that are current version.*Shown as byte*                                                                                                                                        |
| **aws.s3.storagelens.delete_marker_object_count**(gauge)                              | The total number of objects with a delete marker.*Shown as object*                                                                                                                                        |
| **aws.s3.storagelens.delete_marker_storage_bytes**(gauge)                             | The number of bytes in scope that are delete markers.*Shown as byte*                                                                                                                                      |
| **aws.s3.storagelens.delete_requests**(gauge)                                           | The total number of HTTP DELETE requests made.*Shown as request*                                                                                                                                          |
| **aws.s3.storagelens.encrypted_object_count**(gauge)                                   | The total number of objects that are encrypted with S3 server-side encryption.*Shown as object*                                                                                                           |
| **aws.s3.storagelens.encrypted_storage_bytes**(gauge)                                  | The total number of bytes that are encrypted with S3 server-side encryption.*Shown as byte*                                                                                                               |
| **aws.s3.storagelens.event_notification_enabled_bucket_count**(gauge)                | The number of buckets that have Event Notifications enabled.                                                                                                                                              |
| **aws.s3.storagelens.expiration_lifecycle_rule_count**(gauge)                         | The number of lifecycle rules to expire objects.                                                                                                                                                          |
| **aws.s3.storagelens.expired_object_delete_marker_lifecycle_rule_count**(gauge)    | The number of lifecycle rules to remove expired object delete markers.                                                                                                                                    |
| **aws.s3.storagelens.get_requests**(gauge)                                              | The total number of HTTP GET requests made.*Shown as request*                                                                                                                                             |
| **aws.s3.storagelens.head_requests**(gauge)                                             | The total number of HTTP HEAD requests made.*Shown as request*                                                                                                                                            |
| **aws.s3.storagelens.in_region_request_count**(gauge)                                 | The number of requests that originate from a client in the same Region as the bucket's home Region.*Shown as request*                                                                                     |
| **aws.s3.storagelens.in_region_transferred_bytes**(gauge)                             | The number of bytes that are transferred from calls in the same Region as the bucket's home Region.*Shown as byte*                                                                                        |
| **aws.s3.storagelens.incomplete_mpu_object_count_older_than_7_days**(gauge)       | The number of objects that are incomplete multipart uploads more than 7 days old.*Shown as object*                                                                                                        |
| **aws.s3.storagelens.incomplete_mpu_storage_bytes_older_than_7_days**(gauge)      | The total bytes in scope for incomplete multipart uploads that are more than 7 days old.*Shown as byte*                                                                                                   |
| **aws.s3.storagelens.incomplete_multipart_upload_object_count**(gauge)               | The total number of objects with incomplete multipart uploads.*Shown as object*                                                                                                                           |
| **aws.s3.storagelens.incomplete_multipart_upload_storage_bytes**(gauge)              | The total number of bytes with incomplete multipart uploads.*Shown as byte*                                                                                                                               |
| **aws.s3.storagelens.invalid_destination_replication_rule_count**(gauge)             | The number of replication rules with a replication destination that's not valid.                                                                                                                          |
| **aws.s3.storagelens.list_requests**(gauge)                                             | The total number of HTTP requests made that list contents.*Shown as request*                                                                                                                              |
| **aws.s3.storagelens.mfa_delete_enabled_bucket_count**(gauge)                        | The number of buckets that have MFA (multi-factor authentication) delete enabled.                                                                                                                         |
| **aws.s3.storagelens.non_current_version_object_count**(gauge)                       | The total number of objects that are not current version.*Shown as object*                                                                                                                                |
| **aws.s3.storagelens.non_current_version_storage_bytes**(gauge)                      | The total number of bytes that are not current version.*Shown as byte*                                                                                                                                    |
| **aws.s3.storagelens.noncurrent_version_expiration_lifecycle_rule_count**(gauge)    | The number of lifecycle rules to expire noncurrent object versions.                                                                                                                                       |
| **aws.s3.storagelens.noncurrent_version_transition_lifecycle_rule_count**(gauge)    | The number of lifecycle rules to transition noncurrent object versions to another storage class.                                                                                                          |
| **aws.s3.storagelens.object_0kb_count**(gauge)                                         | The number of objects with size equal to 0 KB, including current versions, noncurrent versions, incomplete multipart uploads, and delete markers.*Shown as object*                                        |
| **aws.s3.storagelens.object_0kb_to_128kb_count**(gauge)                              | The number of objects with size greater than 0 KB and less than or equal to 128 KB, including current versions, noncurrent versions, incomplete multipart uploads, and delete markers.*Shown as object*   |
| **aws.s3.storagelens.object_128kb_to_256kb_count**(gauge)                            | The number of objects with size greater than 128 KB and less than or equal to 256 KB, including current versions, noncurrent versions, incomplete multipart uploads, and delete markers.*Shown as object* |
| **aws.s3.storagelens.object_128mb_to_256mb_count**(gauge)                            | The number of objects with size greater than 128 MB and less than or equal to 256 MB, including current versions, noncurrent versions, incomplete multipart uploads, and delete markers.*Shown as object* |
| **aws.s3.storagelens.object_16mb_to_32mb_count**(gauge)                              | The number of objects with size greater than 16 MB and less than or equal to 32 MB, including current versions, noncurrent versions, incomplete multipart uploads, and delete markers.*Shown as object*   |
| **aws.s3.storagelens.object_1gb_to_2gb_count**(gauge)                                | The number of objects with size greater than 1 GB and less than or equal to 2 GB, including current versions, noncurrent versions, incomplete multipart uploads, and delete markers.*Shown as object*     |
| **aws.s3.storagelens.object_1mb_to_2mb_count**(gauge)                                | The number of objects with size greater than 1 MB and less than or equal to 2 MB, including current versions, noncurrent versions, incomplete multipart uploads, and delete markers.*Shown as object*     |
| **aws.s3.storagelens.object_256kb_to_512kb_count**(gauge)                            | The number of objects with size greater than 256 KB and less than or equal to 512 KB, including current versions, noncurrent versions, incomplete multipart uploads, and delete markers.*Shown as object* |
| **aws.s3.storagelens.object_256mb_to_512mb_count**(gauge)                            | The number of objects with size greater than 256 MB and less than or equal to 512 MB, including current versions, noncurrent versions, incomplete multipart uploads, and delete markers.*Shown as object* |
| **aws.s3.storagelens.object_2gb_to_4gb_count**(gauge)                                | The number of objects with size greater than 2 GB and less than or equal to 4 GB, including current versions, noncurrent versions, incomplete multipart uploads, and delete markers.*Shown as object*     |
| **aws.s3.storagelens.object_2mb_to_4mb_count**(gauge)                                | The number of objects with size greater than 2 MB and less than or equal to 4 MB, including current versions, noncurrent versions, incomplete multipart uploads, and delete markers.*Shown as object*     |
| **aws.s3.storagelens.object_32mb_to_64mb_count**(gauge)                              | The number of objects with size greater than 32 MB and less than or equal to 64 MB, including current versions, noncurrent versions, incomplete multipart uploads, and delete markers.*Shown as object*   |
| **aws.s3.storagelens.object_4mb_to_8mb_count**(gauge)                                | The number of objects with size greater than 4 MB and less than or equal to 8 MB, including current versions, noncurrent versions, incomplete multipart uploads, and delete markers.*Shown as object*     |
| **aws.s3.storagelens.object_512kb_to_1mb_count**(gauge)                              | The number of objects with size greater than 512 KB and less than or equal to 1 MB, including current versions, noncurrent versions, incomplete multipart uploads, and delete markers.*Shown as object*   |
| **aws.s3.storagelens.object_512mb_to_1gb_count**(gauge)                              | The number of objects with size greater than 512 MB and less than or equal to 1 GB, including current versions, noncurrent versions, incomplete multipart uploads, and delete markers.*Shown as object*   |
| **aws.s3.storagelens.object_64mb_to_128mb_count**(gauge)                             | The number of objects with size greater than 64 MB and less than or equal to 128 MB, including current versions, noncurrent versions, incomplete multipart uploads, and delete markers.*Shown as object*  |
| **aws.s3.storagelens.object_8mb_to_16mb_count**(gauge)                               | The number of objects with size greater than 8 MB and less than or equal to 16 MB, including current versions, noncurrent versions, incomplete multipart uploads, and delete markers.*Shown as object*    |
| **aws.s3.storagelens.object_count**(gauge)                                              | The total number of objects.*Shown as object*                                                                                                                                                             |
| **aws.s3.storagelens.object_larger_than_4gb_count**(gauge)                           | The number of objects with size greater than 4 GB, including current versions, noncurrent versions, incomplete multipart uploads, and delete markers.*Shown as object*                                    |
| **aws.s3.storagelens.object_lock_enabled_object_count**(gauge)                       | The total number of objects with Object Lock enabled.*Shown as object*                                                                                                                                    |
| **aws.s3.storagelens.object_lock_enabled_storage_bytes**(gauge)                      | The total number of bytes with Object Lock enabled.*Shown as byte*                                                                                                                                        |
| **aws.s3.storagelens.object_ownership_bucket_owner_enforced_bucket_count**(gauge)  | The number of buckets that have access control lists (ACLs) disabled by using the bucket owner enforced setting for Object Ownership.                                                                     |
| **aws.s3.storagelens.object_ownership_bucket_owner_preferred_bucket_count**(gauge) | The number of buckets that use the bucket owner preferred setting for Object Ownership.                                                                                                                   |
| **aws.s3.storagelens.object_ownership_object_writer_bucket_count**(gauge)           | The number of buckets that use the object writer setting for Object Ownership.                                                                                                                            |
| **aws.s3.storagelens.post_requests**(gauge)                                             | The total number of HTTP POST requests made.*Shown as request*                                                                                                                                            |
| **aws.s3.storagelens.put_requests**(gauge)                                              | The total number of HTTP PUT requests made.*Shown as request*                                                                                                                                             |
| **aws.s3.storagelens.read_0kb_request_count**(gauge)                                  | The number of GetObject requests with data sizes of 0 KB, including both range-based requests and whole object requests.*Shown as request*                                                                |
| **aws.s3.storagelens.read_0kb_to_128kb_request_count**(gauge)                       | The number of GetObject requests with data sizes greater than 0 KB and up to 128 KB, including both range-based requests and whole object requests.*Shown as request*                                     |
| **aws.s3.storagelens.read_128kb_to_256kb_request_count**(gauge)                     | The number of GetObject requests with data sizes greater than 128 KB and up to 256 KB, including both range-based requests and whole object requests.*Shown as request*                                   |
| **aws.s3.storagelens.read_128mb_to_256mb_request_count**(gauge)                     | The number of GetObject requests with data sizes greater than 128 MB and up to 256 MB, including both range-based requests and whole object requests.*Shown as request*                                   |
| **aws.s3.storagelens.read_16mb_to_32mb_request_count**(gauge)                       | The number of GetObject requests with data sizes greater than 16 MB and up to 32 MB, including both range-based requests and whole object requests.*Shown as request*                                     |
| **aws.s3.storagelens.read_1gb_to_2gb_request_count**(gauge)                         | The number of GetObject requests with data sizes greater than 1 GB and up to 2 GB, including both range-based requests and whole object requests.*Shown as request*                                       |
| **aws.s3.storagelens.read_1mb_to_2mb_request_count**(gauge)                         | The number of GetObject requests with data sizes greater than 1 MB and up to 2 MB, including both range-based requests and whole object requests.*Shown as request*                                       |
| **aws.s3.storagelens.read_256kb_to_512kb_request_count**(gauge)                     | The number of GetObject requests with data sizes greater than 256 KB and up to 512 KB, including both range-based requests and whole object requests.*Shown as request*                                   |
| **aws.s3.storagelens.read_256mb_to_512mb_request_count**(gauge)                     | The number of GetObject requests with data sizes greater than 256 MB and up to 512 MB, including both range-based requests and whole object requests.*Shown as request*                                   |
| **aws.s3.storagelens.read_2gb_to_4gb_request_count**(gauge)                         | The number of GetObject requests with data sizes greater than 2 GB and up to 4 GB, including both range-based requests and whole object requests.*Shown as request*                                       |
| **aws.s3.storagelens.read_2mb_to_4mb_request_count**(gauge)                         | The number of GetObject requests with data sizes greater than 2 MB and up to 4 MB, including both range-based requests and whole object requests.*Shown as request*                                       |
| **aws.s3.storagelens.read_32mb_to_64mb_request_count**(gauge)                       | The number of GetObject requests with data sizes greater than 32 MB and up to 64 MB, including both range-based requests and whole object requests.*Shown as request*                                     |
| **aws.s3.storagelens.read_4mb_to_8mb_request_count**(gauge)                         | The number of GetObject requests with data sizes greater than 4 MB and up to 8 MB, including both range-based requests and whole object requests.*Shown as request*                                       |
| **aws.s3.storagelens.read_512kb_to_1mb_request_count**(gauge)                       | The number of GetObject requests with data sizes greater than 512 KB and up to 1 MB, including both range-based requests and whole object requests.*Shown as request*                                     |
| **aws.s3.storagelens.read_512mb_to_1gb_request_count**(gauge)                       | The number of GetObject requests with data sizes greater than 512 MB and up to 1 GB, including both range-based requests and whole object requests.*Shown as request*                                     |
| **aws.s3.storagelens.read_64mb_to_128mb_request_count**(gauge)                      | The number of GetObject requests with data sizes greater than 64 MB and up to 128 MB, including both range-based requests and whole object requests.*Shown as request*                                    |
| **aws.s3.storagelens.read_8mb_to_16mb_request_count**(gauge)                        | The number of GetObject requests with data sizes greater than 8 MB and up to 16 MB, including both range-based requests and whole object requests.*Shown as request*                                      |
| **aws.s3.storagelens.read_larger_than_4gb_request_count**(gauge)                    | The number of GetObject requests with data sizes greater than 4 GB, including both range-based requests and whole object requests.*Shown as request*                                                      |
| **aws.s3.storagelens.replicated_object_count**(gauge)                                  | The total number of objects that are replicated.*Shown as object*                                                                                                                                         |
| **aws.s3.storagelens.replicated_object_count_source**(gauge)                          | The number of replicated objects from the source bucket.*Shown as object*                                                                                                                                 |
| **aws.s3.storagelens.replicated_storage_bytes**(gauge)                                 | The total number of bytes that are replicated.*Shown as byte*                                                                                                                                             |
| **aws.s3.storagelens.replicated_storage_bytes_source**(gauge)                         | The number of bytes that are replicated from the source bucket.*Shown as byte*                                                                                                                            |
| **aws.s3.storagelens.same_account_replication_rule_count**(gauge)                    | The number of replication rules for replication within the same account.                                                                                                                                  |
| **aws.s3.storagelens.same_region_replication_rule_count**(gauge)                     | The number of replication rules for Same-Region Replication (SRR).                                                                                                                                        |
| **aws.s3.storagelens.select_requests**(gauge)                                           | The total number of select requests made.*Shown as request*                                                                                                                                               |
| **aws.s3.storagelens.select_returned_bytes**(gauge)                                    | The total number of select bytes returned.*Shown as byte*                                                                                                                                                 |
| **aws.s3.storagelens.select_scanned_bytes**(gauge)                                     | The total number of select bytes scanned.*Shown as byte*                                                                                                                                                  |
| **aws.s3.storagelens.sse_kms_enabled_bucket_count**(gauge)                           | The number of buckets that use server-side encryption with AWS Key Management Service keys (SSE-KMS) for default bucket encryption.                                                                       |
| **aws.s3.storagelens.storage_bytes**(gauge)                                             | The total number of storage bytes.*Shown as byte*                                                                                                                                                         |
| **aws.s3.storagelens.total_lifecycle_rule_count**(gauge)                              | The number of lifecycle rules.                                                                                                                                                                            |
| **aws.s3.storagelens.transfer_acceleration_enabled_bucket_count**(gauge)             | The number of buckets that have Transfer Acceleration enabled.                                                                                                                                            |
| **aws.s3.storagelens.transition_lifecycle_rule_count**(gauge)                         | The number of lifecycle rules to transition objects to another storage class.                                                                                                                             |
| **aws.s3.storagelens.unique_objects_accessed_daily_count**(gauge)                    | The number of objects that were accessed at least once in the last 24 hours.*Shown as object*                                                                                                             |
| **aws.s3.storagelens.versioning_enabled_bucket_count**(gauge)                         | The number of buckets that have S3 Versioning enabled.                                                                                                                                                    |
| **aws.s3.storagelens.write_0kb_request_count**(gauge)                                 | The number of PutObject, UploadPart, and CreateMultipartUpload requests with data sizes of 0 KB.*Shown as request*                                                                                        |
| **aws.s3.storagelens.write_0kb_to_128kb_request_count**(gauge)                      | The number of PutObject, UploadPart, and CreateMultipartUpload requests with data sizes greater than 0 KB and up to 128 KB.*Shown as request*                                                             |
| **aws.s3.storagelens.write_128kb_to_256kb_request_count**(gauge)                    | The number of PutObject, UploadPart, and CreateMultipartUpload requests with data sizes greater than 128 KB and up to 256 KB.*Shown as request*                                                           |
| **aws.s3.storagelens.write_128mb_to_256mb_request_count**(gauge)                    | The number of PutObject, UploadPart, and CreateMultipartUpload requests with data sizes greater than 128 MB and up to 256 MB.*Shown as request*                                                           |
| **aws.s3.storagelens.write_16mb_to_32mb_request_count**(gauge)                      | The number of PutObject, UploadPart, and CreateMultipartUpload requests with data sizes greater than 16 MB and up to 32 MB.*Shown as request*                                                             |
| **aws.s3.storagelens.write_1gb_to_2gb_request_count**(gauge)                        | The number of PutObject, UploadPart, and CreateMultipartUpload requests with data sizes greater than 1 GB and up to 2 GB.*Shown as request*                                                               |
| **aws.s3.storagelens.write_1mb_to_2mb_request_count**(gauge)                        | The number of PutObject, UploadPart, and CreateMultipartUpload requests with data sizes greater than 1 MB and up to 2 MB.*Shown as request*                                                               |
| **aws.s3.storagelens.write_256kb_to_512kb_request_count**(gauge)                    | The number of PutObject, UploadPart, and CreateMultipartUpload requests with data sizes greater than 256 KB and up to 512 KB.*Shown as request*                                                           |
| **aws.s3.storagelens.write_256mb_to_512mb_request_count**(gauge)                    | The number of PutObject, UploadPart, and CreateMultipartUpload requests with data sizes greater than 256 MB and up to 512 MB.*Shown as request*                                                           |
| **aws.s3.storagelens.write_2gb_to_4gb_request_count**(gauge)                        | The number of PutObject, UploadPart, and CreateMultipartUpload requests with data sizes greater than 2 GB and up to 4 GB.*Shown as request*                                                               |
| **aws.s3.storagelens.write_2mb_to_4mb_request_count**(gauge)                        | The number of PutObject, UploadPart, and CreateMultipartUpload requests with data sizes greater than 2 MB and up to 4 MB.*Shown as request*                                                               |
| **aws.s3.storagelens.write_32mb_to_64mb_request_count**(gauge)                      | The number of PutObject, UploadPart, and CreateMultipartUpload requests with data sizes greater than 32 MB and up to 64 MB.*Shown as request*                                                             |
| **aws.s3.storagelens.write_4mb_to_8mb_request_count**(gauge)                        | The number of PutObject, UploadPart, and CreateMultipartUpload requests with data sizes greater than 4 MB and up to 8 MB.*Shown as request*                                                               |
| **aws.s3.storagelens.write_512kb_to_1mb_request_count**(gauge)                      | The number of PutObject, UploadPart, and CreateMultipartUpload requests with data sizes greater than 512 KB and up to 1 MB.*Shown as request*                                                             |
| **aws.s3.storagelens.write_512mb_to_1gb_request_count**(gauge)                      | The number of PutObject, UploadPart, and CreateMultipartUpload requests with data sizes greater than 512 MB and up to 1 GB.*Shown as request*                                                             |
| **aws.s3.storagelens.write_64mb_to_128mb_request_count**(gauge)                     | The number of PutObject, UploadPart, and CreateMultipartUpload requests with data sizes greater than 64 MB and up to 128 MB.*Shown as request*                                                            |
| **aws.s3.storagelens.write_8mb_to_16mb_request_count**(gauge)                       | The number of PutObject, UploadPart, and CreateMultipartUpload requests with data sizes greater than 8 MB and up to 16 MB.*Shown as request*                                                              |
| **aws.s3.storagelens.write_larger_than_4gb_request_count**(gauge)                   | The number of PutObject, UploadPart, and CreateMultipartUpload requests with data sizes greater than 4 GB.*Shown as request*                                                                              |

### Events{% #events %}

The Amazon S3 Storage Lens integration does not include any events.

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

The Amazon S3 Storage Lens integration does not include any service checks.

## Troubleshooting{% #troubleshooting %}

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

## Further Reading{% #further-reading %}

Additional helpful documentation, links, and articles:

- [Monitor and optimize S3 storage with Amazon S3 Storage Lens metrics](https://www.datadoghq.com/blog/amazon-s3-storage-lens-monitoring-datadog/)
