CDN reports and overview

CDN reporting includes Overview for current performance and health, Statistics for standard traffic and response metrics, and optional Advanced Analytics for detailed audience and traffic breakdowns.

CDN Overview in the portal

The Overview page is the default CDN landing page in the CDB Customer Portal. It summarizes CDN performance and traffic across all resources or a selected resource for a specified period.

1. 1

   Open CDN Overview

   In the Customer Portal, navigate to CDN > Overview.

2. 2

   Filter dashboard data

   Select all resources or a specific CDN resource, then select a predefined or custom period.

   

The dashboard groups the metrics into cards:

Card	Information
Health status and traffic summary	Overall health, requests, data transfer, response time, and trends compared with the previous period
Traffic by geography	Request distribution by country
Cache performance	Cached requests, cache hit rate, cached data transfer, and data transfer hit rate
Errors	4xx and 5xx counts and rates
Security	Encrypted requests and encrypted data transfer
Network protocols	HTTP version and content type

Metric status rules

Health status combines the 5xx response rate with the response-time baseline:

• Healthy — the 5xx rate is below 2% and latency is below 1.25 times the baseline
• Degraded — the 5xx rate is between 2% and 5%, or latency is between 1.25 and 2 times the baseline
• Unhealthy — the 5xx rate is at least 5%, or latency is at least 2 times the baseline

The status appears only when the selected period contains more than 1,000 requests and the latest 15-minute window contains more than 20 requests. Otherwise, the dashboard displays Insufficient data.

Cache hit rates above 90% appear in green, rates from 70% through 90% appear as degraded, and rates below 60% appear in red. The red threshold is a visual highlight on the dashboard and is not the troubleshooting threshold used in low cache hit ratio. Encryption rates above 90% appear in green.

Statistics reports for CDN resources

The Statistics report provides traffic, bandwidth, response, cache, request, and timing metrics for selected CDN resources. Basic reports are available on all plans.

📝

For complete data, view statistics at least two days after the selected period ends. Recently completed periods may contain incomplete data.

1. 1

   Open Statistics

   Navigate to CDN > Reports > Statistics.

   
2. 2

   Select resources and the report

   In CDN resource, select one or more resources, then select a report.

   Reports other than Aggregated data include a time interval and an auto-refresh period. Auto-refresh reloads the selected chart on a timer while the page stays open.

3. 3

   Review the report

   The chart and summary metrics adapt to the selected report.

   Charts on this page update while the selected period is still in progress, so they are useful for live monitoring. Complete data for a finished period is available at least two days later, and live charts can still differ from invoice totals because the two sources use different granularity periods.

Available reports

The report menu includes Aggregated data, Traffic, Bandwidth, Response classes, Response codes, Cache hit ratio, Requests, Traffic by region, Traffic by country, Image optimization, Request time, and Upstream response time.

Report	What it shows
Aggregated data	Traffic and bandwidth for the previous three months, with MAX, MIN, and 95th-percentile bandwidth
Traffic by region	Traffic from servers in each region
Traffic by country	Traffic from the five countries with the highest traffic
Image optimization	Hourly WebP conversion count
Request time	Time from processing the first request bytes until logging after the last response bytes are sent
Upstream response time	Time to receive an origin response

Advanced Analytics for CDN resources

Advanced Analytics adds reports for requests, traffic, and unique visitors, with filters for geography, directories, browsers, devices, and operating systems. This paid option requires activation through Support or an account manager.

Until the option is activated, the page shows that Advanced Analytics is not available and an example report with random data. After activation, allow 24 hours for data collection.

1. 1

   Open Advanced Analytics

   Navigate to CDN > Reports > Advanced Analytics.

   
2. 2

   Select report criteria

   Select a CDN resource, a metric type (Requests, Traffic, or Unique visitors), a reporting period, and UTC or local time. Local time only changes how the chart labels timestamps. The stored values remain UTC, which is also the time zone for Overview and Statistics.

   📝

   Unique visitors are counted by the combination of IP address and user agent, not as individual people.
3. 3

   Filter the report

   Select Geography, Directories, Browsers, Devices, or OS, then select the values to include in the chart.

The Geography filter maps traffic by country and compares selected countries in a chart.

Differences between report charts and billing

Invoice totals can differ from the charts above because billing and the Customer Portal read different NGINX sources.

CDB calculates billing and portal reports from different data sources:

• Billing statistics use NGINX access logs because invoice calculation prioritizes accuracy over processing speed.
• Customer Portal reports use the NGINX virtual host traffic status module to provide current resource statistics.

Read traffic and response statistics for a CDN resource, and query advanced analytics for requests, visitors, and bytes.

ℹ️

An API token is required. The CDN resource ID is visible under CDN → CDN Resources, or from the resources list call.

A statistics series returns one value per time block. Aggregated statistics return one total for the whole period. Each metric is a separate metrics parameter. A comma-separated list returns HTTP 204 and an empty body. request_time and upstream_response_time are separate requests; the series names those values request_time_ms and upstream_response_time_ms.

Open a terminal and export the required variables:

export GCORE_API_KEY="{YOUR_API_KEY}"
export CDN_RESOURCE_ID="{YOUR_CDN_RESOURCE_ID}"

Read traffic over time

Set granularity to 1m, 5m, 15m, 1h, or 1d. sent_bytes is traffic from CDN servers to clients. group_by=region splits that series by edge region, and group_by=client_country splits it by the viewer's country code.

import os

from gcore import CDB

client = CDB()
resource_id = int(os.environ["CDN_RESOURCE_ID"])

stats = client.cdn.statistics.get_resource_usage_series(
    service="CDN",
    from_="2026-09-01T00:00:00Z",
    to="2026-09-20T00:00:00Z",
    granularity="1d",
    metrics="sent_bytes",
    resource=resource_id,
)
print(stats.metrics)

package main

import (
    "context"
    "fmt"
    "os"
    "strconv"

    gcore "github.com/G-Core/gcore-go"
    "github.com/G-Core/gcore-go/cdn"
)

func main() {
    client := gcore.NewClient()
    ctx := context.Background()
    resourceID, err := strconv.ParseInt(os.Getenv("CDN_RESOURCE_ID"), 10, 64)
    if err != nil {
        panic(err)
    }

    stats, err := client.CDN.Statistics.GetResourceUsageSeries(ctx, cdn.StatisticGetResourceUsageSeriesParams{
        Service:     "CDN",
        From:        "2026-09-01T00:00:00Z",
        To:          "2026-09-20T00:00:00Z",
        Granularity: "1d",
        Metrics:     "sent_bytes",
        Resource:    gcore.Int(resourceID),
    })
    if err != nil {
        panic(err)
    }
    fmt.Println(stats.Metrics)
}

curl -G "https://api.cdb-staging.cdn.orange.com/cdn/statistics/series" \
  -H "Authorization: APIKey $GCORE_API_KEY" \
  --data-urlencode "service=CDN" \
  --data-urlencode "from=2026-09-01T00:00:00Z" \
  --data-urlencode "to=2026-09-20T00:00:00Z" \
  --data-urlencode "granularity=1d" \
  --data-urlencode "metrics=sent_bytes" \
  --data-urlencode "resource=$CDN_RESOURCE_ID"

The API returns HTTP 200. Each pair is a UNIX timestamp and the bytes sent in that block:

{
  "metrics": {
    "sent_bytes": [
      [1788220800, 16506237],
      [1788307200, 2658488]
    ]
  }
}

Read aggregated bandwidth

max_bandwidth, min_bandwidth, and 95_percentile are bytes per second for the whole period. In the REST request, repeat the metrics parameter to request them together. The Python and Go SDKs send one metrics value per call.

import os

from gcore import CDB

client = CDB()
resource_id = int(os.environ["CDN_RESOURCE_ID"])

stats = client.cdn.statistics.get_resource_usage_aggregated(
    service="CDN",
    from_="2026-09-01T00:00:00Z",
    to="2026-09-20T00:00:00Z",
    metrics="max_bandwidth",
    resource=resource_id,
)
print(stats.metrics)

package main

import (
    "context"
    "fmt"
    "os"
    "strconv"

    gcore "github.com/G-Core/gcore-go"
    "github.com/G-Core/gcore-go/cdn"
)

func main() {
    client := gcore.NewClient()
    ctx := context.Background()
    resourceID, err := strconv.ParseInt(os.Getenv("CDN_RESOURCE_ID"), 10, 64)
    if err != nil {
        panic(err)
    }

    stats, err := client.CDN.Statistics.GetResourceUsageAggregated(ctx, cdn.StatisticGetResourceUsageAggregatedParams{
        Service:  "CDN",
        From:     "2026-09-01T00:00:00Z",
        To:       "2026-09-20T00:00:00Z",
        Metrics:  "max_bandwidth",
        Resource: gcore.Int(resourceID),
    })
    if err != nil {
        panic(err)
    }
    fmt.Println(stats.Metrics)
}

curl -G "https://api.cdb-staging.cdn.orange.com/cdn/statistics/aggregate/stats" \
  -H "Authorization: APIKey $GCORE_API_KEY" \
  --data-urlencode "service=CDN" \
  --data-urlencode "from=2026-09-01T00:00:00Z" \
  --data-urlencode "to=2026-09-20T00:00:00Z" \
  --data-urlencode "metrics=max_bandwidth" \
  --data-urlencode "metrics=min_bandwidth" \
  --data-urlencode "metrics=95_percentile" \
  --data-urlencode "resource=$CDN_RESOURCE_ID"

The API returns HTTP 200:

{
  "metrics": {
    "max_bandwidth": 15573.51,
    "min_bandwidth": 0,
    "95_percentile": 0
  }
}

Read advanced analytics

Advanced Analytics is a paid option. Activate it through Support or an account manager before querying it. After activation, allow 24 hours for data collection.

The query reads requests, visitors, and bytes. groupBy accepts COUNTRY, DIR, BROWSER, DEVICE, and OS.

curl -X POST "https://api.cdb-staging.cdn.orange.com/cdn/advanced/v2/query" \
  -H "Authorization: APIKey $GCORE_API_KEY" \
  -H "Content-Type: application/json" \
  -d "{\"query\":\"query (\$resourceID: Int!) { aggs(resourceID: \$resourceID) { nodes { measures { requests visitors bytes } } } }\",\"variables\":{\"resourceID\":$CDN_RESOURCE_ID}}"

The API returns HTTP 200:

{
  "data": {
    "aggs": {
      "nodes": [
        {
          "measures": {
            "requests": 8271,
            "visitors": 615,
            "bytes": 82772202
          }
        }
      ]
    }
  }
}