---
title: AWS MediaTailor
description: >-
  AWS Elemental MediaTailor is a personalization and monetization service that
  allows scalable server-side ad insertion.
breadcrumbs: Docs > Integrations > AWS MediaTailor
---

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

# AWS MediaTailor
Integration version1.1.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 %}

AWS Elemental MediaTailor is a personalization and monetization service that allows scalable server-side ad insertion.

Enable this integration to see all your Elemental MediaTailor 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 `MediaTailor` is enabled under the `Metric Collection` tab.
1. Install the [Datadog - AWS Elemental MediaTailor integration](https://app.datadoghq.com/integrations/amazon-mediatailor).

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

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

Configure AWS Elemental MediaTailor to send logs either to a S3 bucket or to CloudWatch.

**Note**: If you log to a S3 bucket, make sure that `amazon_mediatailor` 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 AWS Elemental MediaTailor 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.mediatailor.4xx_error_count**(count)                                       | The number of 4xx errors.*Shown as error*                                                                                                                                                                                                                                                             |
| **aws.mediatailor.5xx_error_count**(count)                                       | The number of 5xx errors.*Shown as error*                                                                                                                                                                                                                                                             |
| **aws.mediatailor.ad_decision_server_ads**(count)                               | The count of ads included in ad decision server (ADS) responses for the time period that you specified.                                                                                                                                                                                               |
| **aws.mediatailor.ad_decision_server_duration**(gauge)                          | The total duration in milliseconds of all ads that MediaTailor received from the ADS in the time period that you specified.*Shown as millisecond*                                                                                                                                                     |
| **aws.mediatailor.ad_decision_server_errors**(count)                            | The number of non-HTTP 200 status code responses, empty responses, and timed-out responses that MediaTailor received from the ADS in the time period that you specified.*Shown as error*                                                                                                              |
| **aws.mediatailor.ad_decision_server_fill_rate**(gauge)                        | The simple average of the rates at which the responses from the ADS fill the times available for the corresponding ad avails.*Shown as percent*                                                                                                                                                       |
| **aws.mediatailor.ad_decision_server_latency**(gauge)                           | The response time in milliseconds for requests made by MediaTailor to the ADS.*Shown as millisecond*                                                                                                                                                                                                  |
| **aws.mediatailor.ad_decision_server_overlay_ads**(count)                      | The count of overlay ads included in the ad decision server (ADS) responses within the CloudWatch time period that you specified.                                                                                                                                                                     |
| **aws.mediatailor.ad_decision_server_overlay_errors**(count)                   | The number of non-HTTP 200 status code responses, empty responses, and timed-out responses that MediaTailor received from the ad decision server (ADS) for overlay ads within the CloudWatch time period that you specified.*Shown as error*                                                          |
| **aws.mediatailor.ad_decision_server_overlay_filled**(count)                   | The number of avails that were successfully filled with at least one overlay ad.                                                                                                                                                                                                                      |
| **aws.mediatailor.ad_decision_server_overlay_latency**(gauge)                  | The response time in milliseconds for overlay ad requests that MediaTailor makes to the ad decision server (ADS).*Shown as millisecond*                                                                                                                                                               |
| **aws.mediatailor.ad_decision_server_overlay_min_suggested_duration**(gauge) | The sum of the `minSuggestedDuration` durations, in milliseconds, of all overlay ads that MediaTailor received from the ad decision server (ADS) within the CloudWatch time period that you specified. If `minSuggestedDuration` isn't specified, the planned duration is used.*Shown as millisecond* |
| **aws.mediatailor.ad_decision_server_overlay_timeouts**(count)                 | The number of timed-out overlay ad requests to the ad decision server (ADS) in the CloudWatch time period that you specified.                                                                                                                                                                         |
| **aws.mediatailor.ad_decision_server_timeouts**(count)                          | The number of timed-out requests to the ADS in the time period that you specified.                                                                                                                                                                                                                    |
| **aws.mediatailor.ad_not_ready**(count)                                          | The number of times that the ADS pointed at an ad that wasn't yet transcoded by the internal transcoder service.                                                                                                                                                                                      |
| **aws.mediatailor.ads_billed**(count)                                             | The number of ads for which MediaTailor bills customers based on insertion.                                                                                                                                                                                                                           |
| **aws.mediatailor.avail_complete**(count)                                         | The number of ads for which MediaTailor fired complete beacons during server-side reporting, regardless of whether those beacons were ultimately delivered.                                                                                                                                           |
| **aws.mediatailor.avail_complete_fired**(count)                                  | The number of complete beacons that MediaTailor fired to a given ad tracking domain during server-side reporting, regardless of whether those beacons were ultimately delivered.                                                                                                                      |
| **aws.mediatailor.avail_complete_recovered**(count)                              | The number of complete beacons that were delivered successfully after being retried during server-side reporting.                                                                                                                                                                                     |
| **aws.mediatailor.avail_complete_retried**(count)                                | The number of complete beacons that MediaTailor retried at least once for a given ad tracking domain during server-side reporting.                                                                                                                                                                    |
| **aws.mediatailor.avail_duration**(gauge)                                         | The planned total number of milliseconds of ad avails within the CloudWatch time period. The planned total is based on the ad avail durations in the origin manifest.*Shown as millisecond*                                                                                                           |
| **aws.mediatailor.avail_fill_rate**(gauge)                                       | The planned simple average of the rates at which MediaTailor will fill individual ad avails within the CloudWatch time period.*Shown as percent*                                                                                                                                                      |
| **aws.mediatailor.avail_filled_duration**(gauge)                                 | The planned number of milliseconds of ad avail time that MediaTailor will fill with ads within the CloudWatch time period.*Shown as millisecond*                                                                                                                                                      |
| **aws.mediatailor.avail_first_quartile**(count)                                  | The number of ads for which MediaTailor fired first quartile beacons during server-side reporting, regardless of whether those beacons were ultimately delivered.                                                                                                                                     |
| **aws.mediatailor.avail_impression**(count)                                       | The number of ads for which MediaTailor fired impression beacons during server-side reporting, regardless of whether those beacons were ultimately delivered.                                                                                                                                         |
| **aws.mediatailor.avail_impression_fired**(count)                                | The number of impression beacons that MediaTailor fired to a given ad tracking domain during server-side reporting, regardless of whether those beacons were ultimately delivered.                                                                                                                    |
| **aws.mediatailor.avail_impression_recovered**(count)                            | The number of impression beacons that were delivered successfully after being retried during server-side reporting.                                                                                                                                                                                   |
| **aws.mediatailor.avail_impression_retried**(count)                              | The number of impression beacons that MediaTailor retried at least once for a given ad tracking domain during server-side reporting.                                                                                                                                                                  |
| **aws.mediatailor.avail_late_join**(count)                                       | The number of ad avails that a playback session joined after the avail had already started.                                                                                                                                                                                                           |
| **aws.mediatailor.avail_midpoint**(count)                                         | The number of ads for which MediaTailor fired midpoint beacons during server-side reporting, regardless of whether those beacons were ultimately delivered.                                                                                                                                           |
| **aws.mediatailor.avail_observed_duration**(gauge)                               | The observed total number of milliseconds of ad avails that occurred within the CloudWatch time period. Avail.ObservedDuration is emitted at the end of the ad avail, and is based on the duration of the segments reported in the manifest during the ad avail.*Shown as millisecond*                |
| **aws.mediatailor.avail_observed_fill_rate**(gauge)                             | The observed simple average of the rates at which MediaTailor filled individual ad avails within the CloudWatch time period.*Shown as percent*                                                                                                                                                        |
| **aws.mediatailor.avail_observed_filled_duration**(gauge)                       | The observed number of milliseconds of ad avail time that MediaTailor filled with ads within the CloudWatch time period.*Shown as millisecond*                                                                                                                                                        |
| **aws.mediatailor.avail_observed_slate_duration**(gauge)                        | The observed total number of milliseconds of slate that was inserted within the CloudWatch period.*Shown as millisecond*                                                                                                                                                                              |
| **aws.mediatailor.avail_start**(count)                                            | The number of ads for which MediaTailor fired start beacons during server-side reporting, regardless of whether those beacons were ultimately delivered.                                                                                                                                              |
| **aws.mediatailor.avail_third_quartile**(count)                                  | The number of ads for which MediaTailor fired third quartile beacons during server-side reporting, regardless of whether those beacons were ultimately delivered.                                                                                                                                     |
| **aws.mediatailor.function_errors**(count)                                        | The number of individual function executions that resulted in an error.*Shown as error*                                                                                                                                                                                                               |
| **aws.mediatailor.function_invocations**(count)                                   | The number of times an individual function was executed.*Shown as invocation*                                                                                                                                                                                                                         |
| **aws.mediatailor.function_latency**(gauge)                                       | The execution time in milliseconds for an individual function.*Shown as millisecond*                                                                                                                                                                                                                  |
| **aws.mediatailor.get_manifest_age**(gauge)                                      | The total age of the manifest in milliseconds, measured from when the origin creates the manifest to when MediaTailor sends the personalized manifest.*Shown as millisecond*                                                                                                                          |
| **aws.mediatailor.get_manifest_errors**(count)                                   | The number of errors received when MediaTailor is generating manifests.*Shown as error*                                                                                                                                                                                                               |
| **aws.mediatailor.get_manifest_latency**(gauge)                                  | The MediaTailor response time in milliseconds for the request to generate manifests.*Shown as millisecond*                                                                                                                                                                                            |
| **aws.mediatailor.get_manifest_mediatailor_age**(gauge)                         | The amount of time in milliseconds that the manifest has been stored in MediaTailor, measured from when MediaTailor receives an origin response to when MediaTailor sends the personalized manifest.*Shown as millisecond*                                                                            |
| **aws.mediatailor.origin_age**(gauge)                                             | The amount of time in milliseconds that the origin has the manifest, measured from when the origin creates the manifest to when MediaTailor sends the origin request.*Shown as millisecond*                                                                                                           |
| **aws.mediatailor.origin_errors**(count)                                          | The number of non-HTTP 200 status code responses and timed-out responses that MediaTailor received from the origin server in the time period that you specified.*Shown as error*                                                                                                                      |
| **aws.mediatailor.origin_latency**(gauge)                                         | The response time for requests made by MediaTailor to your content origin server.*Shown as millisecond*                                                                                                                                                                                               |
| **aws.mediatailor.origin_manifest_file_size_bytes**(gauge)                     | The file size of the origin manifest in bytes for both HLS and DASH. Typically this metric is used in conjunction with Origin.ManifestFileSizeTooLarge.*Shown as byte*                                                                                                                                |
| **aws.mediatailor.origin_manifest_file_size_too_large**(count)                | The number of responses from the origin that have a manifest size larger than the configured amount. Typically this metric is used in conjunction with Origin.ManifestFileSizeBytes.                                                                                                                  |
| **aws.mediatailor.origin_timeouts**(count)                                        | The number of timed-out requests to the origin server in the time period that you specified.                                                                                                                                                                                                          |
| **aws.mediatailor.overlay_avail_fill_rate**(gauge)                              | The simple average of the rates at which MediaTailor filled overlay ad avails.*Shown as percent*                                                                                                                                                                                                      |
| **aws.mediatailor.post_ads_response_hook_errors**(count)                       | The number of post-ads response hook executions that resulted in an error.*Shown as error*                                                                                                                                                                                                            |
| **aws.mediatailor.post_ads_response_hook_invocations**(count)                  | The number of times the post-ads response hook was invoked.*Shown as invocation*                                                                                                                                                                                                                      |
| **aws.mediatailor.post_ads_response_hook_latency**(gauge)                      | The execution time in milliseconds for the post-ads response hook.*Shown as millisecond*                                                                                                                                                                                                              |
| **aws.mediatailor.pre_ads_request_hook_errors**(count)                         | The number of pre-ads request hook executions that resulted in an error.*Shown as error*                                                                                                                                                                                                              |
| **aws.mediatailor.pre_ads_request_hook_invocations**(count)                    | The number of times the pre-ads request hook was invoked.*Shown as invocation*                                                                                                                                                                                                                        |
| **aws.mediatailor.pre_ads_request_hook_latency**(gauge)                        | The execution time in milliseconds for the pre-ads request hook.*Shown as millisecond*                                                                                                                                                                                                                |
| **aws.mediatailor.pre_roll_avail_filled_duration**(gauge)                      | The number of milliseconds of pre-roll ad avail time that MediaTailor filled with ads.*Shown as millisecond*                                                                                                                                                                                          |
| **aws.mediatailor.pre_session_init_hook_errors**(count)                        | The number of pre-session initialization hook executions that resulted in an error.*Shown as error*                                                                                                                                                                                                   |
| **aws.mediatailor.pre_session_init_hook_invocations**(count)                   | The number of times the pre-session initialization hook was invoked.*Shown as invocation*                                                                                                                                                                                                             |
| **aws.mediatailor.pre_session_init_hook_latency**(gauge)                       | The execution time in milliseconds for the pre-session initialization hook.*Shown as millisecond*                                                                                                                                                                                                     |
| **aws.mediatailor.request_count**(count)                                          | The total number of requests. The transaction count depends largely on how often players request updated manifests and the number of players. Each player request counts as a transaction.*Shown as request*                                                                                          |
| **aws.mediatailor.requests**(count)                                                | The number of concurrent transactions per second across all request types. The transaction count depends mainly on the number of players and how often the players request updated manifests. Each player request counts as a transaction.*Shown as request*                                          |
| **aws.mediatailor.session_concurrent_streams**(gauge)                            | The number of distinct sessions that MediaTailor served during a one-minute interval.*Shown as session*                                                                                                                                                                                               |
| **aws.mediatailor.session_stream_duration**(gauge)                               | The total elapsed time of a session in milliseconds, measured from when the session was created. The maximum value is the total duration of the session.*Shown as millisecond*                                                                                                                        |
| **aws.mediatailor.session_stream_starts**(count)                                 | The number of sessions that started within the CloudWatch time period that you specified.*Shown as session*                                                                                                                                                                                           |
| **aws.mediatailor.skipped_reason_duration_exceeded**(count)                     | The number of ads that were not inserted into an avail because the ADS returned a duration of ads that was greater than the specified avail duration. A high value for this metric might contribute to a discrepancy between the AdsBilled and AdDecisionServer.Ads metrics.                          |
| **aws.mediatailor.skipped_reason_early_cue_in**(count)                         | The number of ads skipped due to an early CUE-IN.                                                                                                                                                                                                                                                     |
| **aws.mediatailor.skipped_reason_import_error**(count)                          | The number of ads skipped due to an error in the import job.                                                                                                                                                                                                                                          |
| **aws.mediatailor.skipped_reason_import_in_progress**(count)                   | The number of ads skipped due to an existing active import job.                                                                                                                                                                                                                                       |
| **aws.mediatailor.skipped_reason_internal_error**(count)                        | The number of ads skipped due to a MediaTailor internal error.                                                                                                                                                                                                                                        |
| **aws.mediatailor.skipped_reason_new_creative**(count)                          | The number of ads that were not inserted into an avail because it was the first time the asset had been requested by a client. A high value for this metric might temporarily contribute to a low overall Avail.FillRate, until assets can be successfully transcoded.                                |
| **aws.mediatailor.skipped_reason_no_variant_match**(count)                     | The number of ads skipped due to there being no variant match between the ad and content.                                                                                                                                                                                                             |
| **aws.mediatailor.skipped_reason_personalization_threshold_exceeded**(count)   | The duration of ads exceeding the Personalization Threshold setting in this configuration.                                                                                                                                                                                                            |
| **aws.mediatailor.skipped_reason_profile_not_found**(count)                    | The number of ads skipped due to the transcoding profile not being found.                                                                                                                                                                                                                             |
| **aws.mediatailor.skipped_reason_transcode_error**(count)                       | The number of ads skipped due to a transcode error.                                                                                                                                                                                                                                                   |
| **aws.mediatailor.skipped_reason_transcode_in_progress**(count)                | The count of the number of ads that were not inserted into an avail because the ad had not yet been transcoded. A high value for this metric might temporarily contribute to a low overall Avail.FillRate, until the assets can be successfully transcoded.                                           |
| **aws.mediatailor.total_time**(gauge)                                             | The amount of time that the application server took to process the request, including the time used to receive bytes from and write bytes to the client and network.*Shown as millisecond*                                                                                                            |
| **aws.mediatailor.yield_optimization_ads_inserted**(count)                      | The number of Yield Optimization ads inserted into the avail.                                                                                                                                                                                                                                         |

### Events{% #events %}

The AWS Elemental MediaTailor integration does not include any events.

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

The AWS Elemental MediaTailor integration does not include any service checks.

## Troubleshooting{% #troubleshooting %}

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