---
title: Amazon EventBridge
description: >-
  A serverless event bus that processes events from AWS services, SaaS, and your
  apps in near real time.
breadcrumbs: Docs > Integrations > Amazon EventBridge
---

# Amazon EventBridge

{% callout %}
# Important note for users on the following Datadog sites: app.ddog-gov.com

{% alert level="danger" %}
This product is not supported for your selected [Datadog site](https://docs.datadoghq.com/getting_started/site). ().
{% /alert %}

{% /callout %}

## Overview{% #overview %}

Datadog's integration with Amazon EventBridge offers the following features:

- Create custom event buses across your integrated AWS accounts
- Send Datadog alert notification events into the event buses of your choice
- Within AWS, set up triggers on your event buses with services like Kinesis, Lambda, and more
- Use the information within the alert event to execute auto-remediation pipelines and runbooks, run analytics queries, etc.
- This integration is not supported in GovCloud



## Setup{% #setup %}

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

### Installation{% #installation %}

1. Ensure that the main [AWS integration](https://docs.datadoghq.com/integrations/amazon_web_services/) is installed for each AWS account that receives alert notifications.
1. Ensure the following permissions exist in the permissions policy for Datadog AWS Role(s): `events:CreateEventBus` and `events:PutPartnerEvents`.
1. The Amazon EventBridge integration is automatically installed with the main AWS integration.

**Note**: You can also use the [API](https://docs.datadoghq.com/api/latest/aws-integration/#create-an-amazon-eventbridge-source) or [Terraform](https://registry.terraform.io/providers/DataDog/datadog/latest/docs/resources/integration_aws_event_bridge) to set up an Amazon EventBridge source.

### Configuration{% #configuration %}

`events:CreateEventBus` and `events:PutPartnerEvents` permissions are required to send alert notifications to your event buses. If you do not have these permissions set, read the [Datadog IAM permissions documentation](https://docs.datadoghq.com/integrations/amazon_web_services/?tab=allpermissions#datadog-aws-iam-policy) to enable permissions prior to further configuration.

1. Navigate to the [Datadog - Amazon EventBridge integration](https://app.datadoghq.com/integrations/amazon-event-bridge) tile to see a list of AWS accounts integrated in Datadog where you can create Event Bridges.
1. Within the AWS account of choice, create a new event bus by providing a name and selecting the region where you want it to exist.
1. Within Datadog alerts, use the `@awseventbridge-<MY_EVENT_BUS>` syntax to send alert notifications to your event buses.
1. Within AWS, connect your event buses to targets such as Lambda, Kinesis, and [many other services](https://docs.aws.amazon.com/AmazonCloudWatch/latest/events/WhatIsCloudWatchEvents.html) to create event-driven workflows. **Note**: Examples of Datadog use cases can be found on Datadog's partner page in the [AWS Console](https://console.aws.amazon.com/events/home#/partners/datadoghq.com?page=overview).
1. After setting up an event bus in Datadog, navigate to the [Amazon EventBridge console](https://console.aws.amazon.com/events/) and select `Rules` in the navigation pane.
1. Select `Create Rule` and add a name and description for your rule.
1. Under **Define Pattern**, select `Event Pattern`. Select `Predefined by service` as the **event matching pattern**. For **service provider**, select `Service partners`. For **service name**, select `Datadog`. This populates the event buses that are in Datadog. Add any additional information for your rule., then **Save** the rule.
1. To disconnect an event bus in Datadog, hover over the event bus of your choice and press the trash icon. **Note**: This action disconnects the event bus from AWS, but does not delete the event bus itself within AWS.

**Note**: EventBridge rules are not imported into Datadog unless the rule is active and has been triggered.

### Automated actions{% #automated-actions %}

Set up new outbound notification channels for monitors and snapshots from Datadog with the Amazon EventBridge integration. With automated actions, you can configure your AWS resources to:

- Restart a process if process ends for [live process monitoring](https://docs.datadoghq.com/monitors/monitor_types/process/)
- Prompt EC2 reboots
- Prompt ECS Task (kick off another task when one task ends)
- Apply an Ansible Playbook (make any change on hosts)
- Run remote patches
- Run remote SSH scripts
- Run Windows Updates or install applications

The full list of resources you can target is available on the [AWS website](https://docs.aws.amazon.com/eventbridge/latest/userguide/what-is-amazon-eventbridge.html).

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

### Metrics{% #metrics %}

|  |
|  |
| **aws.events.dead\_letter\_invocations**(count)                                                         | The number of times a rule's target isn't invoked in response to an event.                                                                                                                                           |
| **aws.events.events**(count)                                                                            | The number of partner events ingested by EventBridge.                                                                                                                                                                |
| **aws.events.failed\_invocations**(count)                                                               | Measures the number of invocations that failed permanently. This does not include invocations that are retried or that succeeded after a retry attempt                                                               |
| **aws.events.invocation\_attempts**(count)                                                              | Number of times EventBridge attempted invoking a target.                                                                                                                                                             |
| **aws.events.invocations**(count)                                                                       | Measures the number of times a target is invoked for a rule in response to an event. This includes successful and failed invocations but does not include throttled or retried attempts until they fail permanently. |
| **aws.events.invocations\_created**(count)                                                              | The total number of invocations created in response to each event.                                                                                                                                                   |
| **aws.events.invocations\_failed\_to\_be\_sent\_to\_dlq**(count)                                        | The number of invocations that couldn't be moved to a dead-letter queue.                                                                                                                                             |
| **aws.events.ingestion\_to\_invocation\_complete\_latency**(gauge)                                      | Time taken from event ingestion to completion of the first invocation attempt.                                                                                                                                       |
| **aws.events.ingestion\_to\_invocation\_success\_latency**(gauge)                                       | Time taken from event ingestion to successful target delivery.                                                                                                                                                       |
| **aws.events.ingestion\_to\_invocation\_start\_latency**(gauge)                                         | Time to process events, measured from when an event is ingested by EventBridge to first invocation of a target.                                                                                                      |
| **aws.events.invocations\_sent\_to\_dlq**(count)                                                        | The number of invocations that are moved to a dead-letter queue.                                                                                                                                                     |
| **aws.events.matched\_events**(count)                                                                   | Measures the number of events that matched with any rule.                                                                                                                                                            |
| **aws.events.put\_events\_approximate\_call\_count**(count)                                             | Approximate number of received PutEvents requests.                                                                                                                                                                   |
| **aws.events.put\_events\_approximate\_failed\_count**(count)                                           | Approximate number of failed PutEvents requests.                                                                                                                                                                     |
| **aws.events.put\_events\_approximate\_success\_count**(count)                                          | Approximate number of successful PutEvents requests.                                                                                                                                                                 |
| **aws.events.put\_events\_approximate\_throttled\_count**(count)                                        | Approximate number of PutEvents requests rejected due to throttling.                                                                                                                                                 |
| **aws.events.put\_events\_entries\_count**(count)                                                       | The number of event entries contained in a PutEvents request.                                                                                                                                                        |
| **aws.events.put\_events\_failed\_entries\_count**(count)                                               | The number of event entries contained in a PutEvents request that failed to be ingested.                                                                                                                             |
| **aws.events.put\_events\_latency**(gauge)                                                              | The time taken per PutEvents request.*Shown as millisecond*                                                                                                                                                          |
| **aws.events.put\_events\_request\_size**(gauge)                                                        | The size of the PutEvents request.*Shown as byte*                                                                                                                                                                    |
| **aws.events.put\_partner\_events\_approximate\_call\_count**(count)                                    | Approximate number of received PutPartnerEvents requests.                                                                                                                                                            |
| **aws.events.put\_partner\_events\_approximate\_failed\_count**(count)                                  | Approximate number of failed PutPartnerEvents requests.                                                                                                                                                              |
| **aws.events.put\_partner\_events\_approximate\_success\_count**(count)                                 | Approximate number of successful PutPartnerEvents requests.                                                                                                                                                          |
| **aws.events.put\_partner\_events\_approximate\_throttled\_count**(count)                               | Approximate number of PutPartnerEvents requests rejected due to throttling.                                                                                                                                          |
| **aws.events.put\_partner\_events\_entries\_count**(count)                                              | The number of event entries contained in a PutPartnerEvents request.                                                                                                                                                 |
| **aws.events.put\_partner\_events\_failed\_entries\_count**(count)                                      | The number of event entries contained in a PutPartnerEvents request that failed to be ingested.                                                                                                                      |
| **aws.events.put\_partner\_events\_latency**(gauge)                                                     | The time taken per PutPartnerEvents request.*Shown as millisecond*                                                                                                                                                   |
| **aws.events.retry\_invocation\_attempts**(count)                                                       | Number of times target invocation has been retried.                                                                                                                                                                  |
| **aws.events.successful\_invocation\_attempts**(count)                                                  | Number of times target was successfully invoked.                                                                                                                                                                     |
| **aws.events.throttled\_rules**(count)                                                                  | Measures the number of triggered rules that are being throttled.                                                                                                                                                     |
| **aws.events.triggered\_rules**(count)                                                                  | Measures the number of triggered rules that matched with any event.                                                                                                                                                  |
| **aws.eventbridge.pipes.concurrency**(gauge)                                                            | The number of concurrent executions of a pipe.                                                                                                                                                                       |
| **aws.eventbridge.pipes.duration**(gauge)                                                               | Length of time the pipe execution took.*Shown as millisecond*                                                                                                                                                        |
| **aws.eventbridge.pipes.event\_count**(count)                                                           | The number of events a pipe has processed.                                                                                                                                                                           |
| **aws.eventbridge.pipes.event\_size**(gauge)                                                            | The size of the payload of the event that invoked the pipe.*Shown as byte*                                                                                                                                           |
| **aws.eventbridge.pipes.execution\_throttled**(count)                                                   | How many executions of a pipe were throttled.                                                                                                                                                                        |
| **aws.eventbridge.pipes.execution\_timeout**(count)                                                     | How many executions of a pipe timed out before completing execution.                                                                                                                                                 |
| **aws.eventbridge.pipes.execution\_failed**(count)                                                      | How many executions of a pipe failed.                                                                                                                                                                                |
| **aws.eventbridge.pipes.execution\_partially\_failed**(count)                                           | How many executions of a pipe partially failed.                                                                                                                                                                      |
| **aws.eventbridge.pipes.enrichment\_stage\_duration**(gauge)                                            | How long the enrichment stage took to complete.*Shown as millisecond*                                                                                                                                                |
| **aws.eventbridge.pipes.enrichment\_stage\_failed**(count)                                              | How many executions of a pipe's enrichment stage failed.                                                                                                                                                             |
| **aws.eventbridge.pipes.invocations**(count)                                                            | Total number of invocations.                                                                                                                                                                                         |
| **aws.eventbridge.pipes.target\_stage\_duration**(gauge)                                                | How long the target stage took to complete.*Shown as millisecond*                                                                                                                                                    |
| **aws.eventbridge.pipes.target\_stage\_failed**(count)                                                  | How many executions of a pipe's target stage failed.                                                                                                                                                                 |
| **aws.eventbridge.pipes.target\_stage\_partially\_failed**(count)                                       | How many executions of a pipe's target stage partially failed.                                                                                                                                                       |
| **aws.eventbridge.pipes.target\_stage\_skipped**(count)                                                 | How many executions of a pipe's target stage were skipped.                                                                                                                                                           |
| **aws.scheduler.invocation\_attempt\_count**(count)                                                     | Emitted for every invocation attempt.                                                                                                                                                                                |
| **aws.scheduler.target\_error\_count**(count)                                                           | Emitted when the target returns an exception after EventBridge Scheduler calls the target API.                                                                                                                       |
| **aws.scheduler.target\_error\_throttled\_count**(count)                                                | Emitted when target invocation fails due to API throttling by the target.                                                                                                                                            |
| **aws.scheduler.invocation\_throttle\_count**(count)                                                    | Emitted when EventBridge Scheduler throttles a target invocation because it exceeds your service quotas set by EventBridge Scheduler.                                                                                |
| **aws.scheduler.invocation\_dropped\_count**(count)                                                     | Emitted when EventBridge Scheduler stops attempting to invoke the target after a schedule's retry policy has been exhausted.                                                                                         |
| **aws.scheduler.invocations\_sent\_to\_dead\_letter\_count**(count)                                     | Emitted for every successful delivery to a schedule's DLQ.                                                                                                                                                           |
| **aws.scheduler.invocations\_failed\_to\_be\_sent\_to\_dead\_letter\_count**(count)                     | Emitted when EventBridge Scheduler cannot deliver an event to the DLQ.                                                                                                                                               |
| **aws.scheduler.invocations\_sent\_to\_dead\_letter\_count\_truncated\_message\_size\_exceeded**(count) | Emitted when the payload of the event sent to the DLQ exceeds the maximum size allowed by Amazon SQS.                                                                                                                |

### Events{% #events %}

The Amazon EventBridge integration does not include any events.

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

The Amazon EventBridge integration does not include any service checks.

## Troubleshooting{% #troubleshooting %}

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