---
title: Fastly
description: View key Fastly metrics in context with the rest of your Datadog metrics.
breadcrumbs: Docs > Integrations > Fastly
---

# Fastly
Integration version1.4.2   Fastly DashboardFastly DashboardFastly Dashboard
## Overview{% #overview %}

Connect Fastly to Datadog to gain real-time visibility into your edge delivery performance and services. Using [Fastly's Real-Time Analytics API](https://www.fastly.com/documentation/reference/api/metrics-stats/realtime/), this integration collects key metrics such as cache hit ratios, error rates, request latency, and traffic volume. It also supports Fastly-specific features like Compute, On-the-Fly Packager, Image Optimizer, and Origin Shield. Out-of-the-box dashboards and monitors help you visualize trends, pivot between metrics and logs, and create alerts based on thresholds or anomalies.

In addition to metrics, Fastly supports [Real-Time Log Streaming](https://www.fastly.com/documentation/guides/integrations/logging-endpoints/log-streaming-datadog/) to send request-level logs, containing headers, cache statuses, and geolocation details, directly to Datadog. When paired with other telemetry, Fastly logs provide context for root cause analysis, traffic debugging, and enriched analytics. [Enable Fastly log collection](https://docs.datadoghq.com/integrations/fastly.md#log-collection) to get unified observability across your CDN and core infrastructure.

Finally, use the [Fastly Cloud Cost Management Integration](https://app.datadoghq.com/integrations?integrationId=fastly-cost-management) to integrate Fastly with [Datadog Cloud Cost Management](https://www.datadoghq.com/product/cloud-cost-management/) and get details on monthly total spend, resource optimization recommendations, and cost change monitors.

## Setup{% #setup %}

### Installation{% #installation %}

No installation steps required.

### Configuration{% #configuration %}

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

Create a Read-only access API token on Fastly's token management page, get your Service ID from the Dashboard and enter them in the [Fastly integration tile](https://app.datadoghq.com/account/settings#integrations/fastly).

{% alert level="info" %}
The ServiceID is the alphanumerical code, for example: `5VqE6MOOy1QFJbgmCK41pY` (example from the [Fastly API documentation](https://docs.fastly.com/api/auth)).
{% /alert %}

If you are using multiple Service IDs from one account, enter an API token on each line.

The account name is a way for you to organize your accounts, and is not used as part of the data ingestion process.

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

{% callout %}
# Important note for users on the following Datadog sites: us3.datadoghq.com

Log collection is not supported for this site.
{% /callout %}

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



Configure the Datadog endpoint to forward Fastly logs to Datadog. You can choose the `Datadog` or `Datadog (via Syslog)` endpoint. The `Datadog` endpoint is recommended for more reliable delivery of logs over Syslog.

##### Select the logging endpoint{% #select-the-logging-endpoint %}

1. Log in to the Fastly web interface and click **Configure link**.
1. From the **Service** menu, select the appropriate service.
1. Click the **Configuration** button and then select **Clone active**. The Domains page appears.
1. Click the **Logging** link. The logging endpoints page appears. Click **Create Endpoint** under **Datadog** or the **Datadog (with Syslog)** options.

##### Configure the Datadog endpoint (recommended){% #configure-the-datadog-endpoint-recommended %}

1. Give a name to the endpoint, for example: `Datadog`.
1. Configure the log format. By default, the recommended [Datadog-Fastly log format](https://docs.fastly.com/en/guides/log-streaming-datadog#using-the-json-logging-format) is already provided and can be customized.
1. Select your region to match your Datadog account region:
1. Add your [Datadog API key](https://app.datadoghq.com/organization-settings/api-keys).
1. Click **Create** at the bottom.
1. Click **Activate** at the top right to activate the new configuration. After a few minutes, logs should begin flowing into your account.

##### Configure the Syslog endpoint{% #configure-the-syslog-endpoint %}

1. Give a name to the endpoint, for example: `Datadog`.

1. Configure the log format to include the recommended Datadog-Fastly log format with [your Datadog API key](https://app.datadoghq.com/organization-settings/api-keys) at the beginning. See [Using the JSON logging format](https://docs.fastly.com/en/guides/log-streaming-datadog#using-the-json-logging-format) in the Fastly documentation for an example.

   ```text
   <DATADOG_API_KEY> <DATADOG_FASTLY_LOG_FORMAT>
   ```

**Note**: Your Datadog API key MUST be in front of the Datadog-Fastly log format for your logs to display in Datadog. See [Useful variables to log](https://docs.fastly.com/guides/streaming-logs/useful-variables-to-log) for more details.

1. Set **Syslog Address** to: 

1. Set **Port** to: 

1. Set **TLS** to `yes`

1. Set **TLS Hostname** to: 

1. In the advanced option section, select `Blank` as **log line format**

1. Finally, save the endpoint and deploy the service. See the logs in your [Datadog Logs Explorer](https://app.datadoghq.com/logs).


{% /callout %}

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

### Metrics{% #metrics %}

|  |
|  |
| **fastly.all\_status\_1xx**(gauge)                          | Number of "Informational" category status codes delivered for all sources*Shown as response*                                                                                                                                                                                                                |
| **fastly.all\_status\_2xx**(gauge)                          | Number of "Success" status codes delivered for all sources*Shown as response*                                                                                                                                                                                                                               |
| **fastly.all\_status\_3xx**(gauge)                          | Number of "Redirection" codes delivered for all sources*Shown as response*                                                                                                                                                                                                                                  |
| **fastly.all\_status\_4xx**(gauge)                          | Number of "Client Error" codes delivered for all sources*Shown as response*                                                                                                                                                                                                                                 |
| **fastly.all\_status\_5xx**(gauge)                          | Number of "Server Error" codes delivered for all sources*Shown as response*                                                                                                                                                                                                                                 |
| **fastly.attack\_blocked\_req\_body\_bytes**(gauge)         | Total body bytes received from requests that triggered a WAF rule that was blocked*Shown as byte*                                                                                                                                                                                                           |
| **fastly.attack\_blocked\_req\_header\_bytes**(gauge)       | Total header bytes received from requests that triggered a WAF rule that was blocked*Shown as byte*                                                                                                                                                                                                         |
| **fastly.attack\_logged\_req\_body\_bytes**(gauge)          | Total body bytes received from requests that triggered a WAF rule that was logged*Shown as byte*                                                                                                                                                                                                            |
| **fastly.attack\_logged\_req\_header\_bytes**(gauge)        | Total header bytes received from requests that triggered a WAF rule that was logged*Shown as byte*                                                                                                                                                                                                          |
| **fastly.attack\_passed\_req\_body\_bytes**(gauge)          | Total body bytes received from requests that triggered a WAF rule that was passed*Shown as byte*                                                                                                                                                                                                            |
| **fastly.attack\_passed\_req\_header\_bytes**(gauge)        | Total header bytes received from requests that triggered a WAF rule that was passed*Shown as byte*                                                                                                                                                                                                          |
| **fastly.attack\_req\_body\_bytes**(gauge)                  | Total body bytes received from requests that triggered a WAF rule*Shown as byte*                                                                                                                                                                                                                            |
| **fastly.attack\_req\_header\_bytes**(gauge)                | Total header bytes received from requests that triggered a WAF rule*Shown as byte*                                                                                                                                                                                                                          |
| **fastly.attack\_resp\_synth\_bytes**(gauge)                | Total bytes delivered for requests that triggered a WAF rule and returned a synthetic response*Shown as byte*                                                                                                                                                                                               |
| **fastly.attack\_synth**(gauge)                             |
| **fastly.bandwidth**(gauge)                                 | Bandwidth sent.*Shown as byte*                                                                                                                                                                                                                                                                              |
| **fastly.blacklist**(gauge)                                 |
| **fastly.body\_size**(gauge)                                | Request body bandwidth sent.*Shown as byte*                                                                                                                                                                                                                                                                 |
| **fastly.compute\_bereq\_errors**(gauge)                    | Number of backend request errors including timeouts*Shown as request*                                                                                                                                                                                                                                       |
| **fastly.compute\_bereqs**(gauge)                           | Number of backend requests started*Shown as request*                                                                                                                                                                                                                                                        |
| **fastly.compute\_execution\_time\_ms**(gauge)              | Amount of active CPU time used to process your requests (in milliseconds)*Shown as millisecond*                                                                                                                                                                                                             |
| **fastly.compute\_ram\_used**(gauge)                        | Amount of RAM used for your service by Fastly (in bytes)*Shown as byte*                                                                                                                                                                                                                                     |
| **fastly.compute\_request\_time\_ms**(gauge)                | Total actual amount of time used to process your requests including active CPU time (in milliseconds)*Shown as millisecond*                                                                                                                                                                                 |
| **fastly.compute\_requests**(gauge)                         | Total number of requests that were received for your service by Fastly*Shown as request*                                                                                                                                                                                                                    |
| **fastly.compute\_resource\_limit\_exceeded**(gauge)        | Number of times a guest exceeded its resource limit, including heap, stack, globals, and code execution timeout*Shown as time*                                                                                                                                                                              |
| **fastly.edge\_hit\_requests**(gauge)                       | Number of requests sent by end users to Fastly that resulted in a hit at the edge*Shown as request*                                                                                                                                                                                                         |
| **fastly.edge\_hit\_resp\_body\_bytes**(gauge)              | Body bytes delivered for edge hits*Shown as byte*                                                                                                                                                                                                                                                           |
| **fastly.edge\_hit\_resp\_header\_bytes**(gauge)            | Header bytes delivered for edge hits*Shown as byte*                                                                                                                                                                                                                                                         |
| **fastly.edge\_miss\_requests**(gauge)                      | Number of requests sent by end users to Fastly that resulted in a miss at the edge*Shown as request*                                                                                                                                                                                                        |
| **fastly.edge\_miss\_resp\_body\_bytes**(gauge)             | Body bytes delivered for edge misses*Shown as byte*                                                                                                                                                                                                                                                         |
| **fastly.edge\_miss\_resp\_header\_bytes**(gauge)           | Header bytes delivered for edge misses*Shown as byte*                                                                                                                                                                                                                                                       |
| **fastly.edge\_requests**(gauge)                            | Number of requests sent by end users to Fastly*Shown as request*                                                                                                                                                                                                                                            |
| **fastly.edge\_resp\_body\_bytes**(gauge)                   | Total body bytes delivered from Fastly to the end user*Shown as byte*                                                                                                                                                                                                                                       |
| **fastly.edge\_resp\_header\_bytes**(gauge)                 | Total header bytes delivered from Fastly to the end user*Shown as byte*                                                                                                                                                                                                                                     |
| **fastly.errors**(gauge)                                    | Number of Errors.*Shown as request*                                                                                                                                                                                                                                                                         |
| **fastly.fanout\_bereq\_body\_bytes**(gauge)                | Total body or message content bytes sent to backends over Fanout connections.*Shown as byte*                                                                                                                                                                                                                |
| **fastly.fanout\_bereq\_header\_bytes**(gauge)              | Total header bytes sent to backends over Fanout connections.*Shown as byte*                                                                                                                                                                                                                                 |
| **fastly.fanout\_beresp\_body\_bytes**(gauge)               | Total body or message content bytes received from backends over Fanout connections.*Shown as byte*                                                                                                                                                                                                          |
| **fastly.fanout\_beresp\_header\_bytes**(gauge)             | Total header bytes received from backends over Fanout connections.*Shown as byte*                                                                                                                                                                                                                           |
| **fastly.fanout\_conn\_time\_ms**(gauge)                    | Total duration of Fanout connections with end users.*Shown as millisecond*                                                                                                                                                                                                                                  |
| **fastly.fanout\_recv\_publishes**(gauge)                   | Total published messages received from the publish API endpoint.*Shown as request*                                                                                                                                                                                                                          |
| **fastly.fanout\_req\_body\_bytes**(gauge)                  | Total body or message content bytes received from end users over Fanout connections.*Shown as byte*                                                                                                                                                                                                         |
| **fastly.fanout\_req\_header\_bytes**(gauge)                | Total header bytes received from end users over Fanout connections.*Shown as byte*                                                                                                                                                                                                                          |
| **fastly.fanout\_resp\_body\_bytes**(gauge)                 | Total body or message content bytes sent to end users over Fanout connections excluding published message content.*Shown as byte*                                                                                                                                                                           |
| **fastly.fanout\_resp\_header\_bytes**(gauge)               | Total header bytes sent to end users over Fanout connections.*Shown as byte*                                                                                                                                                                                                                                |
| **fastly.fanout\_send\_publishes**(gauge)                   | Total published messages sent to end users.*Shown as request*                                                                                                                                                                                                                                               |
| **fastly.header\_size**(gauge)                              | Request header bandwidth sent.*Shown as byte*                                                                                                                                                                                                                                                               |
| **fastly.hit\_ratio**(gauge)                                | Ratio of cache hits to cache misses.*Shown as percent*                                                                                                                                                                                                                                                      |
| **fastly.hits**(gauge)                                      | Number of cache hits.*Shown as request*                                                                                                                                                                                                                                                                     |
| **fastly.hits\_time**(gauge)                                | Amount of time spent processing cache hits.*Shown as second*                                                                                                                                                                                                                                                |
| **fastly.http2**(gauge)                                     | Number of requests that were received over HTTP2*Shown as request*                                                                                                                                                                                                                                          |
| **fastly.http3**(gauge)                                     | Number of requests received over HTTP/3*Shown as request*                                                                                                                                                                                                                                                   |
| **fastly.imgopto**(gauge)                                   | Number of responses that came from the Fastly Image Optimizer service*Shown as response*                                                                                                                                                                                                                    |
| **fastly.imgopto\_resp\_body\_bytes**(gauge)                | Total body bytes delivered from the Fastly Image Optimizer service*Shown as byte*                                                                                                                                                                                                                           |
| **fastly.imgopto\_resp\_header\_bytes**(gauge)              | Total header bytes delivered from the Fastly Image Optimizer service*Shown as byte*                                                                                                                                                                                                                         |
| **fastly.imgopto\_shield\_resp\_body\_bytes**(gauge)        | Total body bytes delivered via a shield from the Fastly Image Optimizer service*Shown as byte*                                                                                                                                                                                                              |
| **fastly.imgopto\_shield\_resp\_header\_bytes**(gauge)      | Total header bytes delivered via a shield from the Fastly Image Optimizer service*Shown as byte*                                                                                                                                                                                                            |
| **fastly.imgvideo**(gauge)                                  | Number of video responses that came from the Fastly Image Optimizer service*Shown as response*                                                                                                                                                                                                              |
| **fastly.imgvideo\_frames**(gauge)                          | Number of video frames that came from the Fastly Image Optimizer service*Shown as response*                                                                                                                                                                                                                 |
| **fastly.imgvideo\_resp\_body\_bytes**(gauge)               | Total body bytes of video delivered from the Fastly Image Optimizer service*Shown as byte*                                                                                                                                                                                                                  |
| **fastly.imgvideo\_resp\_header\_bytes**(gauge)             | Total header bytes of video delivered from the Fastly Image Optimizer service*Shown as byte*                                                                                                                                                                                                                |
| **fastly.imgvideo\_shield**(gauge)                          | Number of video responses delivered via a shield that came from the Fastly Image Optimizer service*Shown as response*                                                                                                                                                                                       |
| **fastly.imgvideo\_shield\_frames**(gauge)                  | Number of video frames delivered via a shield that came from the Fastly Image Optimizer service*Shown as response*                                                                                                                                                                                          |
| **fastly.imgvideo\_shield\_resp\_body\_bytes**(gauge)       | Total body bytes of video delivered via a shield from the Fastly Image Optimizer service*Shown as byte*                                                                                                                                                                                                     |
| **fastly.imgvideo\_shield\_resp\_header\_bytes**(gauge)     | Total header bytes of video delivered via a shield from the Fastly Image Optimizer service*Shown as byte*                                                                                                                                                                                                   |
| **fastly.ipv6**(gauge)                                      | Number of requests that were received over IPv6*Shown as request*                                                                                                                                                                                                                                           |
| **fastly.log**(gauge)                                       | Number of log lines sent                                                                                                                                                                                                                                                                                    |
| **fastly.log\_bytes**(gauge)                                | Total log bytes sent*Shown as byte*                                                                                                                                                                                                                                                                         |
| **fastly.miss**(gauge)                                      | Number of cache misses.*Shown as request*                                                                                                                                                                                                                                                                   |
| **fastly.miss\_time**(gauge)                                | Amount of time spent processing cache misses.*Shown as second*                                                                                                                                                                                                                                              |
| **fastly.object\_size\_100k**(gauge)                        | Number of objects served that were between 10KB and 100KB in size*Shown as object*                                                                                                                                                                                                                          |
| **fastly.object\_size\_100m**(gauge)                        | Number of objects served that were between 10MB and 100MB in size*Shown as object*                                                                                                                                                                                                                          |
| **fastly.object\_size\_10k**(gauge)                         | Number of objects served that were between 1KB and 10KB in size*Shown as object*                                                                                                                                                                                                                            |
| **fastly.object\_size\_10m**(gauge)                         | Number of objects served that were between 1MB and 10MB in size*Shown as object*                                                                                                                                                                                                                            |
| **fastly.object\_size\_1g**(gauge)                          | Number of objects served that were between 100MB and 1GB in size*Shown as object*                                                                                                                                                                                                                           |
| **fastly.object\_size\_1k**(gauge)                          | Number of objects served that were under 1KB in size*Shown as object*                                                                                                                                                                                                                                       |
| **fastly.object\_size\_1m**(gauge)                          | Number of objects served that were between 100KB and 1MB in size*Shown as object*                                                                                                                                                                                                                           |
| **fastly.orig\_req\_body\_size**(gauge)                     | Total body bytes sent to origin*Shown as byte*                                                                                                                                                                                                                                                              |
| **fastly.orig\_req\_header\_size**(gauge)                   | Total header bytes sent to origin*Shown as byte*                                                                                                                                                                                                                                                            |
| **fastly.orig\_resp\_body\_size**(gauge)                    | Total body bytes sent from origin*Shown as byte*                                                                                                                                                                                                                                                            |
| **fastly.orig\_resp\_header\_size**(gauge)                  | Total header bytes sent from origin*Shown as byte*                                                                                                                                                                                                                                                          |
| **fastly.origin\_cache\_fetch\_resp\_body\_bytes**(gauge)   | Body bytes received from origin for cacheable content*Shown as byte*                                                                                                                                                                                                                                        |
| **fastly.origin\_cache\_fetch\_resp\_header\_bytes**(gauge) | Header bytes received from an origin for cacheable content*Shown as byte*                                                                                                                                                                                                                                   |
| **fastly.origin\_cache\_fetches**(gauge)                    | Total number of completed requests made to backends (origins) that returned cacheable content*Shown as request*                                                                                                                                                                                             |
| **fastly.origin\_fetch\_body\_bytes**(gauge)                | Total request body bytes sent to origin*Shown as byte*                                                                                                                                                                                                                                                      |
| **fastly.origin\_fetch\_header\_bytes**(gauge)              | Total request header bytes sent to origin*Shown as byte*                                                                                                                                                                                                                                                    |
| **fastly.origin\_fetch\_resp\_body\_bytes**(gauge)          | Total body bytes received from origin*Shown as byte*                                                                                                                                                                                                                                                        |
| **fastly.origin\_fetch\_resp\_header\_bytes**(gauge)        | Total header bytes received from origin*Shown as byte*                                                                                                                                                                                                                                                      |
| **fastly.origin\_fetches**(gauge)                           | Number of requests sent to origin*Shown as request*                                                                                                                                                                                                                                                         |
| **fastly.origin\_revalidations**(gauge)                     | Number of responses received from origin with a 304 status code in response to an If-Modified-Since or If-None-Match request. Under regular scenarios, a revalidation implies a cache hit. However, if using Fastly Image Optimizer or segmented caching this may result in a cache miss*Shown as response* |
| **fastly.otfp**(gauge)                                      | Number of responses that came from the Fastly On-the-Fly-Packager for On Demand Streaming service for Video-on-Demand*Shown as response*                                                                                                                                                                    |
| **fastly.otfp\_deliver\_time**(gauge)                       | Total amount of time spent delivering a response from the Fastly On-the-Fly Packager for On Demand Streaming service for video-on-demand*Shown as second*                                                                                                                                                   |
| **fastly.otfp\_manifests**(gauge)                           | Number of responses that were manifest files from the Fastly On-the-Fly Packager for On Demand Streaming service for video-on-demand*Shown as response*                                                                                                                                                     |
| **fastly.otfp\_resp\_body\_bytes**(gauge)                   | Total body bytes delivered from the Fastly On-the-Fly Packager for On Demand Streaming service for video-on-demand*Shown as byte*                                                                                                                                                                           |
| **fastly.otfp\_resp\_header\_bytes**(gauge)                 | Total header bytes delivered from the Fastly On-the-Fly Packager for On Demand Streaming service for video-on-demand*Shown as byte*                                                                                                                                                                         |
| **fastly.otfp\_shield\_resp\_body\_bytes**(gauge)           | Total body bytes delivered via a shield for the Fastly On-the-Fly Packager for On Demand Streaming service for video-on-demand*Shown as byte*                                                                                                                                                               |
| **fastly.otfp\_shield\_resp\_header\_bytes**(gauge)         | Total header bytes delivered via a shield for the Fastly On-the-Fly Packager for On Demand Streaming service for video-on-demand*Shown as byte*                                                                                                                                                             |
| **fastly.otfp\_shield\_time**(gauge)                        | Total amount of time spent delivering a response via a sheild from the Fastly On-the-Fly Packager for On Demand Streaming service for video-on-demand*Shown as second*                                                                                                                                      |
| **fastly.pass**(gauge)                                      | Number of requests passed through the CDN without being cached.*Shown as request*                                                                                                                                                                                                                           |
| **fastly.pass\_time**(gauge)                                | Amount of time spent processing cache passes*Shown as second*                                                                                                                                                                                                                                               |
| **fastly.pci**(gauge)                                       | Number of responses that have the PCI flag turned on*Shown as response*                                                                                                                                                                                                                                     |
| **fastly.pipe**(gauge)                                      | Number of pipe operations performed.*Shown as operation*                                                                                                                                                                                                                                                    |
| **fastly.req\_body\_bytes**(gauge)                          | Total body bytes received*Shown as byte*                                                                                                                                                                                                                                                                    |
| **fastly.req\_header\_bytes**(gauge)                        | Total header bytes received*Shown as byte*                                                                                                                                                                                                                                                                  |
| **fastly.requests**(gauge)                                  | Number of Requests Processed.*Shown as request*                                                                                                                                                                                                                                                             |
| **fastly.resp\_body\_bytes**(gauge)                         | Total body bytes delivered*Shown as byte*                                                                                                                                                                                                                                                                   |
| **fastly.resp\_header\_bytes**(gauge)                       | Total header bytes delivered.*Shown as byte*                                                                                                                                                                                                                                                                |
| **fastly.restarts**(gauge)                                  | Number of restarts performed                                                                                                                                                                                                                                                                                |
| **fastly.shield**(gauge)                                    | Number of requests from edge to the shield POP.*Shown as request*                                                                                                                                                                                                                                           |
| **fastly.shield\_cache\_fetches**(gauge)                    | Total number of completed requests made to shields that returned cacheable content*Shown as request*                                                                                                                                                                                                        |
| **fastly.shield\_fetch\_body\_bytes**(gauge)                | Total request body bytes sent to a shield*Shown as byte*                                                                                                                                                                                                                                                    |
| **fastly.shield\_fetch\_header\_bytes**(gauge)              | Total request header bytes sent to a shield*Shown as byte*                                                                                                                                                                                                                                                  |
| **fastly.shield\_fetch\_resp\_body\_bytes**(gauge)          | Total response body bytes sent from a shield to the edge*Shown as byte*                                                                                                                                                                                                                                     |
| **fastly.shield\_fetch\_resp\_header\_bytes**(gauge)        | Total response header bytes sent from a shield to the edge*Shown as byte*                                                                                                                                                                                                                                   |
| **fastly.shield\_fetches**(gauge)                           | Number of requests made from one Fastly POP to another, as part of shielding*Shown as request*                                                                                                                                                                                                              |
| **fastly.shield\_hit\_requests**(gauge)                     | Number of requests that resulted in a hit at a shield*Shown as request*                                                                                                                                                                                                                                     |
| **fastly.shield\_hit\_resp\_body\_bytes**(gauge)            | Body bytes delivered for shield hits*Shown as byte*                                                                                                                                                                                                                                                         |
| **fastly.shield\_hit\_resp\_header\_bytes**(gauge)          | Header bytes delivered for shield hits*Shown as byte*                                                                                                                                                                                                                                                       |
| **fastly.shield\_miss\_requests**(gauge)                    | Number of requests that resulted in a miss at a shield*Shown as request*                                                                                                                                                                                                                                    |
| **fastly.shield\_miss\_resp\_body\_bytes**(gauge)           | Body bytes delivered for shield misses*Shown as byte*                                                                                                                                                                                                                                                       |
| **fastly.shield\_miss\_resp\_header\_bytes**(gauge)         | Header bytes delivered for shield misses*Shown as byte*                                                                                                                                                                                                                                                     |
| **fastly.shield\_resp\_body\_bytes**(gauge)                 | Total body bytes delivered via a shield*Shown as byte*                                                                                                                                                                                                                                                      |
| **fastly.shield\_resp\_header\_bytes**(gauge)               | Total header bytes delivered via a shield*Shown as byte*                                                                                                                                                                                                                                                    |
| **fastly.shield\_revalidations**(gauge)                     | Number of responses received from origin with a 304 status code, in response to an If-Modified-Since or If-None-Match request to a shield. Under regular scenarios, a revalidation implies a cache hit. However, if using segmented caching this may result in a cache miss*Shown as response*              |
| **fastly.status\_1xx**(gauge)                               | Number of responses sent with an Informational status code.*Shown as response*                                                                                                                                                                                                                              |
| **fastly.status\_200**(gauge)                               | Number of responses sent with status code 200 (Success).*Shown as response*                                                                                                                                                                                                                                 |
| **fastly.status\_204**(gauge)                               | Number of responses sent with status code 204 (No Content).*Shown as response*                                                                                                                                                                                                                              |
| **fastly.status\_2xx**(gauge)                               | Number of responses sent with a Success status code.*Shown as response*                                                                                                                                                                                                                                     |
| **fastly.status\_301**(gauge)                               | Number of responses sent with status code 301 (Moved Permanently).*Shown as response*                                                                                                                                                                                                                       |
| **fastly.status\_302**(gauge)                               | Number of responses sent with status code 302 (Found).*Shown as response*                                                                                                                                                                                                                                   |
| **fastly.status\_304**(gauge)                               | Number of responses sent with status code 304 (Not Modified).*Shown as response*                                                                                                                                                                                                                            |
| **fastly.status\_3xx**(gauge)                               | Number of responses sent with a Redirection status code.*Shown as response*                                                                                                                                                                                                                                 |
| **fastly.status\_400**(gauge)                               | Number of responses sent with status code 400 (Bad Request)*Shown as response*                                                                                                                                                                                                                              |
| **fastly.status\_401**(gauge)                               | Number of responses sent with status code 401 (Unauthorized)*Shown as response*                                                                                                                                                                                                                             |
| **fastly.status\_403**(gauge)                               | Number of responses sent with status code 403 (Forbidden)*Shown as response*                                                                                                                                                                                                                                |
| **fastly.status\_404**(gauge)                               | Number of responses sent with status code 404 (Not Found)*Shown as response*                                                                                                                                                                                                                                |
| **fastly.status\_416**(gauge)                               | Number of responses sent with status code 416 (Range Not Satisfiable)*Shown as response*                                                                                                                                                                                                                    |
| **fastly.status\_4xx**(gauge)                               | Number of responses sent with a Client Error status code.*Shown as response*                                                                                                                                                                                                                                |
| **fastly.status\_500**(gauge)                               | Number of responses sent with status code 500 (Internal Server Error)*Shown as response*                                                                                                                                                                                                                    |
| **fastly.status\_501**(gauge)                               | Number of responses sent with status code 501 (Not Implemented)*Shown as response*                                                                                                                                                                                                                          |
| **fastly.status\_502**(gauge)                               | Number of responses sent with status code 502 (Bad Gateway)*Shown as response*                                                                                                                                                                                                                              |
| **fastly.status\_503**(gauge)                               | Number of responses sent with status code 503 (Service Unavailable).*Shown as response*                                                                                                                                                                                                                     |
| **fastly.status\_504**(gauge)                               | Number of responses sent with status code 504 (Gateway Timeout)*Shown as response*                                                                                                                                                                                                                          |
| **fastly.status\_505**(gauge)                               | Number of responses sent with status code 505 (HTTP Version Not Supported)*Shown as response*                                                                                                                                                                                                               |
| **fastly.status\_5xx**(gauge)                               | Number of responses sent with a Server Error status code.*Shown as response*                                                                                                                                                                                                                                |
| **fastly.synth**(gauge)                                     |
| **fastly.tls**(gauge)                                       | Number of requests that were received over TLS*Shown as request*                                                                                                                                                                                                                                            |
| **fastly.tls\_v10**(gauge)                                  | Number of requests received over TLS 1.0*Shown as request*                                                                                                                                                                                                                                                  |
| **fastly.tls\_v11**(gauge)                                  | Number of requests received over TLS 1.1*Shown as request*                                                                                                                                                                                                                                                  |
| **fastly.tls\_v12**(gauge)                                  | Number of requests received over TLS 1.2*Shown as request*                                                                                                                                                                                                                                                  |
| **fastly.tls\_v13**(gauge)                                  | Number of requests received over TLS 1.3*Shown as request*                                                                                                                                                                                                                                                  |
| **fastly.uncacheable**(gauge)                               | Number of requests that were denoted uncachable.*Shown as request*                                                                                                                                                                                                                                          |
| **fastly.video**(gauge)                                     | Number of responses with video segment or video manifest MIME type*Shown as response*                                                                                                                                                                                                                       |
| **fastly.waf\_blocked**(gauge)                              | Number of requests that triggered a WAF rule and were blocked*Shown as request*                                                                                                                                                                                                                             |
| **fastly.waf\_logged**(gauge)                               | Number of requests that triggered a WAF rule and were logged*Shown as request*                                                                                                                                                                                                                              |
| **fastly.waf\_passed**(gauge)                               | Number of requests that triggered a WAF rule and were passed*Shown as request*                                                                                                                                                                                                                              |

### Events{% #events %}

The Fastly integration does not include any events.

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

The Fastly integration does not include any service checks.

## Troubleshooting{% #troubleshooting %}

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