Response

Each request for your content will generate a response from a server. This response consists of:

Protocol and Version

Identifies the network protocol and version (e.g., HTTP/1.1) used to transmit the response to the client. This protocol and version typically matches the one defined in the request. If an invalid protocol or version was requested, then the response will return a 505 HTTP Version Not Supported.

Status Codes

HTTP status codes are how the web signals errors and other states from the server to the web browser. If there is an error from your backend website, the error is simply forwarded by Edgio to the browser.

Edgio exclusive status codes

If the error is generated in Edgio itself, the platform generates a 53x or 54x HTTP status code:

CODE	NAME	DESCRIPTION
530	Internal Edgio Error	Unexpected error in Edgio. Please contact support immediately.
531	Project Upstream Connection Error	Your project failed to establish an upstream connection. This is different from 536 where your project timed out waiting for a response from the upstream. Common causes are the upstream host you specified in your project is incorrect, the DNS entry you defined points to the wrong server, your servers are not responding, or you need to add the Edgio IP addresses to your allowlist. (Contact your operations team and ask them to add the IP addresses in Allowlisting to your server’s IP allowlist.)
532	Project Response Too Large	Your project returned a response size greater than the allowed 6MB.
533	Project Upstream TLS Error	The was an error negotiating a secure TLS connection with the upstream. Common causes are the host name provided does not match the name in the upstream TLS certificate, or the upstream TLS certificate has expired.
534	Project Error	Your project’s serverless code has failed unexpectedly or has issued a malformed response. Use server logs to debug.
535	Unknown Project	The HTTP header `host` is missing or does not match any Edgio deployment. Check your requesting URL and your project config.
536	Project HTTP Response Timeout	Edgio did not receive an HTTP response from the upstream. Common causes are the upstream dropped the connection prematurely, the upstream application threw an exception, and the upstream took too long to respond.
537	Project DNS Resolution Error	Failed to resolve the host name through DNS, which might indicate a problem with your DNS provider or incorrectly configured domain name.
538	Project Request Loop	The Edgio project exceeded the maximum level (3) of nested Edgio requests. “Nested” means an Edgio site is the upstream of itself or of another Edgio site.
539	Project Timeout	The 539 status code is primarily caused by timeouts, but can also be caused by lack of allow lists (white lists) configured on your backend server. Timeouts: Your project’s serverless code did not respond on time, either due to slow or blocking upstream or to badly handled asynchronous requests in code (e.g. missing `await` or call to `callback`). Troubleshooting: You can view the timings and status codes of the components in the stack in the x-0-t header Use server logs and performance profiling to debug. You can also debug using information in Troubleshooting 539 Status Codes, which includes information about detecting allow list errors.
540	Out of Memory	Your project’s serverless code caused an out-of-memory situation. Use server logs to debug and lower the memory use.
541	Edgio Out of Workers	The traffic was so high that the request could not be scheduled for processing within the scheduling timeout. Please contact support to upgrade your account.
542	Project Header Overflow	The Edgio project’s request or response had too many HTTP headers. See limits
543	Global Upstream Timeout	The request failed to propagate between Edgio edge and the global POP. Please contact support.
544	Invalid Host Header	The Edgio received a value in `host` header that is not a valid domain name.
545	Edgio Component Not Ready	An unprepared Edgio component received traffic. Please contact support immediately.
546	Edgio Global POP TLS Error	The was an error negotiating a secure TLS connection with the Edgio global POP. Please contact support immediately.
547	Edgio Global POP No HTTP Response	Edgio did not receive an HTTP response from the global POP. Please contact support immediately.
548	Edgio Global POP DNS Resolution Error	Edgio failed to resolve the global POP’s host name through DNS. Please contact support immediately.

Obviously, your project can set status codes of their own, which may sometimes match codes above. We encourage you to avoid setting your own status code so as to lower troubleshooting overhead and other issues.

Standard status codes used by Edgio itself

Edgio also issues these standard response codes:

CODE	NAME	DESCRIPTION
400	Bad Request	The URL is too long or the request headers are too large. See limits
404	Not Found	The server cannot find the requested resource. This usually occurs when the browser requests a page that your app does not have. A 404 will also occur when a request does not match any of the routes in your Edgio router. See routing for more information.
412	Precondition Failed	This code is returned when the query string parameter `edgio_prefetch` equals `1` and the content was not found in the edge cache.

Reserved Response Headers

The x-0-* headers namespace is reserved for Edgio internal use and setting them yourself, except where so noted, is unsupported. See Prohibited Headers for more information.

x-0-caching-status: Indicates cache status information. If the response was not cached or served from cache, then it will report the reason why it was not cached.

Example:

The following sample response header indicates that caching was explictly disabled for this request:

x-0-caching-status: disabled

Learn more.

x-0-components: Indicates the version for each POP component that processed the request and the environment ID. This response header is primarily meant for internal use when troubleshooting issues.
x-0-hit-request-id: If the response is served from cache, this header indicates the unique ID of the request whose response was cached.
x-0-request-id: Indicates the request’s unique ID.
x-0-status: Contains a comma-delimited list of HTTP status codes for each POP component that processed the request.
x-0-surrogate-key: Contains a space-delimited list of surrogate keys (cache tags).

Learn more.
x-0-t: Contains time measurements for each Edgio component through which a request was routed. It also provides cache status information for edge and global POPs.
x-0-version: Describes the Edgio deployment.

x-0-status Response Header

The x-0-status response header contains an HTTP status code for each POP component that processed the request. This comma-delimited list is presented sequentially according to the order in which POP components processed the request.

Syntax: x-0-status: <POP Component 1>=<Status Code 1>[,<POP Component 2>=<Status Code 2>,<POP Component n>=<Status Code n>]

A POP component is identified through the following two abbreviations:

x-0-t Response Header

The x-0-t response header contains time measurements for each Edgio POP component through which a request was routed. It also provides cache status information for edge and global POPs. This data is presented sequentially according to the order in which POP components processed the request.

Learn how Edgio routes requests.

Syntax:

x-0-t: <Metric 1>=<Value 1>[,<Metric 2>=<Value 2>,<Metric n>=<Value n>]

Each metric is defined through a set of abbreviations. These abbreviations identify:

Who handled the request:
- e: Edge POP
- g: Global POP
If a global POP is the closest POP to the client, then it will act as both an edge and global POP. However, it will be assigned the e abbrevation instead of g.
For example, you may typically measure an origin server’s response time through gdf (Global POP’s DPS Fetch Time). However, if a global POP is the closest POP to the client, then you should use edf instead since Edgio will not return gdf.
- p: Serverless Compute (load balancer)
- w: Serverless Compute (worker)
The POP component that processed the request:
- d: Dynamic Proxy Service (DPS)
- b: Billing
- k: Kolben
The type of metric being measured:
- c: This abbreviation represents either of the following metrics:
  - Cache status. Valid values are:
    - hit: The response was served from cache.
    - miss: The response was forwarded to the next hop in the route because a cached response with a valid time-to-live (TTL) was not found. This value, which may only be returned when cached or pass is inapplicable, typically indicates that the response contains a set-cookie header or its status code is 4xx or higher.
    - cached: The response was cached as a result of this request.
    - pass: The route corresponding to this request or cache-specific response headers prohibit caching.
    For example, gcc=miss identifies a cache miss on a global POP. A global POP forwards requests that result in cache misses to either an origin server or Serverless Compute.
  - Request count.
    
    For example, pc=1 indicates the number of requests generated by the Serverless Compute (load balancer). A value greater than 1 indicates that the load balancer had to scale the request by adding it to a queue and then resubmitting it. Another example is wc=19 which indicates that a Serverless Compute (worker) was invoked 19 times by this request.
- d: DNS lookup time in milliseconds.
  
  DPS uses DNS caching to accelerate requests. This means that DPS may frequently report a DNS lookup time of 0.
  
  For example, edd identifies the DNS lookup time as measured by an edge POP’s DPS.
- f: Fetch time in milliseconds. This metric measures the amount of time between when a POP component forwards a request and when it receives a response.
  
  For example, gdf indicates the amount of time between when a global POP’s DPS forwarded a request to an origin server or Serverless Compute and when it started receiving a response.
- g: Age in seconds.
  
  For example, wg=746940 indicates that the instance of the Serverless Compute (worker) that processed the request has been running for approximately 747 seconds.
- l: Sum of time in milliseconds.
  
  For example, wl=30896 indicates the total processing time for all Serverless Compute (workers) for all requests is 30.8 seconds.
- m: Memory usage in Megabytes.
  
  For example, wm=317 indicates that Serverless Compute (worker) used 317 Megabytes of memory for this request.
- r: Route evaluation in milliseconds.
  
  For example, wr=1 indicates that Serverless Compute (worker) spent 1 millisecond evaluating the route through which this request will be processed.
- t: Total time in milliseconds. This metric measures the amount of time between the moment when the request was received to when a response was sent to the client.
  
  For example, wbt indicates billed time as measured by a Serverless Compute load balancer. This measurement includes Serverless Compute workload time and time spent capturing Serverless Compute log data.
- u: Upstream fetch time in milliseconds.
  
  For example, pu identifies the total time between when a Serverless Compute load balancer submitted a request defined within your application’s code (e.g., fetch) and when it received a response.
- cw: Wait in the request coalescing queue.
  
  For example, ecwt identifies the total time the request spent waiting in the request coalescing queue on the edge POP. The analogue for the global POP is gcwt. These are useful to check when apparent cache hits have high total time. Those cases are actually due to request coalescing resulting in a cache hit.

Exceptions

Most metrics follow the above convention. However, there are some metrics that use a different convention. Here are a few common exceptions to the above convention:

dgpop: Identifies the global POP to which an edge POP forwarded a request.
wa: Indicates the transformRequest time, in milliseconds, as measured by a Serverless Compute (worker).
wp: Indicates the fetch or proxy time, in milliseconds, as measured by a Serverless Compute (worker).
wz: Indicates either:
- transformResponse: If the route uses transformResponse, then this metric measures the transformResponse time in milliseconds.
- Image Optimization: If the route contains an image optimization tag, such as Next Image or Nuxt nuxt-img, instead of transformResponse, then this metric measures processing time in milliseconds.

x-0-version Response Header

The x-0-version response header describes the latest Edgio deployment using the following syntax:

x-0-version: <Deployment Number> <Package Version> <Environment Version> <Deployment Timestamp> <Compiler Version>

Definitions for the above variables are provided below.

<Deployment Number>: Identifies a deployment by its version number.
<Package Version>: Indicates the Edgio package version.
<Environment Version>: Identifies an environment by its version number.
<Deployment Timestamp>: Indicates the date and time (UTC; 24-hour clock) at which your site was deployed.

Syntax: YYYY-MM-DDThh:mm:ss.msZ
<Compiler Version>: Indicates the Edgio compiler version through which your site was compiled.

Example:

x-0-version: 23 4.17.1 3 2022-09-15T12:54:14.721Z 1.5.0

Server Timing Response Header

Edgio adds the following values to the standard server-timing response header:

edgio-cache: <Cache Status>: Valid cache statuses are:
- HIT-L1: Indicates that the request was served from an edge POP’s cache.
- HIT-L2: Indicates that the request was served from a global POP’s cache.
- MISS: Indicates that the request was not served from cache.
country: <Country Code>: Indicates the two-letter code for the country from which the request was sent.
xrj: <Route>: Indicates the route that Edgio mapped to the request. This route is serialized into JSON.

Serverless Compute - Cold Start Timing

To calculate the Serverless cold start timing you must take the difference between pf and wt in the x-0-t header. wt is time taken for the Serverless Compute worker to execute after it has started, this is can be read as the time is takes the project code to execute. If that seems large, evaluate the code within your project to see why this might be. To track timings for a function, it is possible to add specific code to do that.

Based on the example above, that would be 809 (pf) - 722 (wt) = 87ms.

Response Body

Contains the data provided in response to the request.

For example, the response body for a GET request for a text file might look similar to the following:

1Hello World!