Getting Amazon S3 request IDs for AWS Support

The type of logger and the verbosity are specified during the SDK initialization in the SDKOptions argument. The following example specifies the verbosity level as LogLevel::Debug.

The default logger will write to the filesystem and the file is named using the following convention aws_sdk_YYYY-MM-DD-HH.log. The logger creates a new file on the hour.

Aws::SDKOptions options;
options.loggingOptions.logLevel = Aws::Utils::Logging::LogLevel::Debug;
Aws::InitAPI(options);
// ...
Aws::ShutdownAPI(options);

For more information, see How do I turn on logging? in the AWS SDK for C++ wiki on GitHub.

You can configure logging by using SDK for Go. For more information, see Logging in the AWS SDK for Go v2 Developer Guide.

You can enable logging for specific requests or responses to catch and return only relevant headers. To do this, import the com.amazonaws.services.s3.S3ResponseMetadata class. Afterward, you can store the request in a variable before performing the actual request. To get the logged request or response, call getCachedResponseMetadata(AmazonWebServiceRequest request).getRequestID().

PutObjectRequest req = new PutObjectRequest(bucketName, key, createSampleFile());
s3.putObject(req);
S3ResponseMetadata md = s3.getCachedResponseMetadata(req);
System.out.println("Host ID: " + md.getHostId() + " RequestID: " + md.getRequestId());

Alternatively, you can use verbose logging of every Java request and response. For more information, see Verbose Wire Logging in the AWS SDK for Java Developer Guide.

The AWS SDK for JavaScript has a built-in logger so you can log API calls you make with it. To turn on the logger and print log entries in the console, add the following statement to your code:

AWS.config.logger = console;

For more information, see Logging AWS SDK for JavaScript Calls in the AWS SDK for JavaScript Developer Guide.

With the AWS SDK for Kotlin, you can specify log mode for wire-level messages using code or environment settings. You can set log mode for HTTP requests and HTTP responses.

To opt into additional logging, set the logMode property when you construct a service client:

import aws.smithy.kotlin.runtime.client.LogMode

// ...

val client = DynamoDbClient {
    // ...
    logMode = LogMode.LogRequestWithBody + LogMode.LogResponse
}

Alternatively, you can set log mode using an environment variable:

export SDK_LOG_MODE=LogRequestWithBody|LogResponse

For more information, see Logging in the AWS SDK for Kotlin Developer Guide.

You can configure logging with the SDK for .NET by using the built-in System.Diagnostics logging tool. For more information, see the Logging with the SDK for .NET AWS Developer Blog post.

You can get debug information, including the data sent over the wire, by setting the debug option to true in a client constructor.

$s3Client = new Aws\S3\S3Client([
    'region'  => 'us-standard',
    'version' => '2006-03-01',
    'debug'   => true
]);

For more information, see How can I see what data is sent over the wire? in the AWS SDK for PHP Developer Guide.

With the AWS SDK for Python (Boto3), you can log specific responses. You can use this feature to capture only the relevant headers. The following code shows how to log parts of the response to a file:

import logging
import boto3
logging.basicConfig(filename='logfile.txt', level=logging.INFO)
logger = logging.getLogger(__name__)
s3 = boto3.resource('s3')
response = s3.Bucket(bucket_name).Object(object_key).put()
logger.info("HTTPStatusCode: %s", response['ResponseMetadata']['HTTPStatusCode'])
logger.info("RequestId: %s", response['ResponseMetadata']['RequestId'])
logger.info("HostId: %s", response['ResponseMetadata']['HostId'])
logger.info("Date: %s", response['ResponseMetadata']['HTTPHeaders']['date'])

You can also catch exceptions and log relevant information when an exception is raised. For more information, see Discerning useful information from error responses in the AWS SDK for Python (Boto) API Reference.

Additionally, you can configure Boto3 to output verbose debugging logs by using the following code:

import logging
import boto3
boto3.set_stream_logger('', logging.DEBUG)

For more information, see set_stream_logger in the AWS SDK for Python (Boto) API Reference.

You can get your request IDs using the SDK for Ruby Version 3. You can enable HTTP wire logging in your client using the following code:

s3 = Aws::S3::Client.new(http_wire_trace: true)

You can also find the request ID of the request context object in the request response or error:

# Finding the request ID from an error:
begin
  s3.put_object(bucket: 'bucket', key: 'key', body: 'test')
rescue Aws::S3::Errors::ServiceError => e
  puts e.context[:request_id]
  puts e.context[:s3_host_id]
end

# Finding the request ID from a successful call:
resp = s3.put_object(bucket: 'bucket', key: 'key', body: 'test')
puts resp.context[:request_id]
puts resp.context[:s3_host_id]

For more information, see Debugging using wire trace information from an AWS SDK for Ruby client in the AWS SDK for Ruby Developer Guide.

To enable logging, add the tracing-subscriber crate and initialize it in your Rust application.

Add the tracing library to your Cargo.toml file:

tracing-subscriber = { version = "0.3", features = ["env-filter"] }

Then, in your Rust code, initialize the logger in the main function before you call any SDK operation:

tracing_subscriber::fmt::init();

For more information, see Configuring and using logging in the AWS SDK for Rust in the AWS SDK for Rust Developer Guide.