---
title: Amazon Redshift
description: >-
  A managed, petabyte-scale data warehouse solution for cost-effectively and
  efficiently analyzing data.
breadcrumbs: Docs > Integrations > Amazon Redshift
---

# Amazon Redshift

## Overview{% #overview %}

Amazon Redshift is a fast, fully managed, petabyte-scale data warehouse service that makes it simple and cost-effective to efficiently analyze all your data.

Enable this integration to see all your Redshift metrics in Datadog.

## Setup{% #setup %}

### Installation{% #installation %}

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

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

1. In the [AWS integration page](https://app.datadoghq.com/integrations/amazon-web-services), ensure that `Redshift` is enabled under the `Metric Collection` tab.

1. Add these permissions to your [Datadog IAM policy](https://docs.datadoghq.com/integrations/amazon_web_services/#installation) in order to collect Amazon Redshift metrics:

   - `redshift:DescribeClusters`: List all Redshift Clusters in your account.
   - `redshift:DescribeLoggingStatus`: Get S3 bucket where Redshift logs are stored.
   - `tag:GetResources`: Get custom tags on your Redshift clusters.

For more information, see the [Redshift policies](https://docs.aws.amazon.com/redshift/latest/mgmt/redshift-iam-authentication-access-control.html) on the AWS website.

1. Install the [Datadog - Amazon Redshift integration](https://app.datadoghq.com/integrations/amazon-redshift).

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

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

Enable the logging on your Redshift Cluster first to collect your logs. Redshift logs can be written to an Amazon S3 bucket and [consumed by a Lambda function](https://docs.datadoghq.com/logs/guide/send-aws-services-logs-with-the-datadog-lambda-function/#collecting-logs-from-s3-buckets). For more information, see [Configuring auditing using the console](https://docs.aws.amazon.com/redshift/latest/mgmt/db-auditing-console.html).

#### 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/) in your AWS account.

1. Once the Lambda function is installed, there are two ways to collect your Redshift logs:

   - Automatically: Redshift logs are managed automatically if you grant Datadog access with a set of permissions. See [Automatically Set Up Triggers](https://docs.datadoghq.com/logs/guide/send-aws-services-logs-with-the-datadog-lambda-function/#automatically-set-up-triggers) for more information on configuring automatic log collection on the Datadog Forwarder Lambda function.
   - Manually: In the AWS console, add a trigger on the S3 bucket that contains your Redshift logs. See the manual installation steps.

#### Manual installation steps{% #manual-installation-steps %}

1. If you haven't already, set up the [Datadog Forwarder Lambda function](https://docs.datadoghq.com/logs/guide/forwarder/) in your AWS account.
1. Once set up, go to the Datadog Forwarder Lambda function. In the Function Overview section, click **Add Trigger**.
1. Select the **S3** trigger for the Trigger Configuration.
1. Select the S3 bucket that contains your Redshift logs.
1. Leave the event type as `All object create events`.
1. Click **Add** to add the trigger to your Lambda.

Go to the [Log Explorer](https://app.datadoghq.com/logs) to start exploring your logs.

For more information on collecting AWS Services logs, see [Send AWS Services Logs with the Datadog Lambda Function](https://docs.datadoghq.com/logs/guide/send-aws-services-logs-with-the-datadog-lambda-function/).

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

### Metrics{% #metrics %}

|  |
|  |
| **aws.redshift.commit\_queue\_length**(count)                           | The number of transactions ahead of a transaction in the commit queue.*Shown as transaction*                                                                       |
| **aws.redshift.concurrency\_scaling\_active\_clusters**(count)          | The number of concurrency scaling clusters that are actively processing queries at any given time.                                                                 |
| **aws.redshift.concurrency\_scaling\_seconds**(gauge)                   | The number of seconds used by concurrency scaling clusters that have active query processing activity.*Shown as second*                                            |
| **aws.redshift.cpuutilization**(gauge)                                  | The percentage of CPU utilization. For clusters, this metric represents an aggregation of all nodes (leader and compute) CPU utilization values.*Shown as percent* |
| **aws.redshift.database\_connections**(gauge)                           | The number of database connections to a cluster.*Shown as connection*                                                                                              |
| **aws.redshift.health\_status**(gauge)                                  | Indicates the health of the cluster. 1 indicates healthy, and 0 indicates unhealthy.                                                                               |
| **aws.redshift.maintenance\_mode**(gauge)                               | Indicates whether the cluster is in maintenance mode. 1 indicates on, and 0 indicates off.                                                                         |
| **aws.redshift.max\_configured\_concurrency\_scaling\_clusters**(count) | The maximum number of concurrency scaling clusters configured from the parameter group.                                                                            |
| **aws.redshift.network\_receive\_throughput**(rate)                     | The rate at which the node or cluster receives data.*Shown as byte*                                                                                                |
| **aws.redshift.network\_transmit\_throughput**(rate)                    | The rate at which the node or cluster writes data.*Shown as byte*                                                                                                  |
| **aws.redshift.num\_exceeded\_schema\_quotas**(count)                   | The number of schemas with exceeded quotas.                                                                                                                        |
| **aws.redshift.percentage\_disk\_space\_used**(gauge)                   | The percent of disk space used.*Shown as percent*                                                                                                                  |
| **aws.redshift.percentage\_quota\_used**(gauge)                         | The percentage of disk or storage space used relative to the configured schema quota.*Shown as percent*                                                            |
| **aws.redshift.queries\_completed\_per\_second**(count)                 | The average number of queries completed per second. Reported in five-minute intervals.*Shown as query*                                                             |
| **aws.redshift.query\_duration**(gauge)                                 | The average amount of time to complete a query. Reported in five-minute intervals.*Shown as microsecond*                                                           |
| **aws.redshift.query\_runtime\_breakdown**(gauge)                       | AWS Redshift query runtime breakdown                                                                                                                               |
| **aws.redshift.read\_iops**(rate)                                       | The average number of disk read operations per second.*Shown as operation*                                                                                         |
| **aws.redshift.read\_latency**(gauge)                                   | The average amount of time taken for disk read I/O operations.*Shown as second*                                                                                    |
| **aws.redshift.read\_throughput**(rate)                                 | The average number of bytes read from disk per second.*Shown as byte*                                                                                              |
| **aws.redshift.schema\_quota**(gauge)                                   | The configured quota for a schema.*Shown as byte*                                                                                                                  |
| **aws.redshift.storage\_used**(gauge)                                   | The disk or storage space used by a schema.*Shown as byte*                                                                                                         |
| **aws.redshift.total\_table\_count**(count)                             | The number of user tables open at a particular point in time. This total does not include Spectrum tables.*Shown as table*                                         |
| **aws.redshift.wlmqueries\_completed\_per\_second**(count)              | The average number of queries completed per second for a workload management (WLM) queue. Reported in five-minute intervals.*Shown as query*                       |
| **aws.redshift.wlmquery\_duration**(gauge)                              | The average length of time to complete a query for a workload management (WLM) queue. Reported in five-minute intervals.*Shown as microsecond*                     |
| **aws.redshift.wlmqueue\_length**(count)                                | The number of queries waiting to enter a workload management (WLM) queue.*Shown as query*                                                                          |
| **aws.redshift.wlmqueue\_wait\_time**(gauge)                            | The total time queries spent waiting in the workload management (WLM) queue.*Shown as millisecond*                                                                 |
| **aws.redshift.wlmrunning\_queries**(count)                             | The number of queries running from both the main cluster and Concurrency Scaling cluster per WLM queue.*Shown as query*                                            |
| **aws.redshift.write\_iops**(rate)                                      | The average number of write operations per second.*Shown as operation*                                                                                             |
| **aws.redshift.write\_latency**(gauge)                                  | The average amount of time taken for disk write I/O operations.*Shown as second*                                                                                   |
| **aws.redshift.write\_throughput**(rate)                                | The average number of bytes written to disk per second.*Shown as byte*                                                                                             |

Each of the metrics retrieved from AWS are assigned the same tags that appear in the AWS console, including but not limited to host name, security-groups, and more.

### Events{% #events %}

The Amazon Redshift integration does not include any events.

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

The Amazon Redshift integration does not include any service checks.

## Troubleshooting{% #troubleshooting %}

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