Version: 1.0
Date: August 2025
Dataset: cloudlookingglass
Cloud Looking Glass provides independent, real-time monitoring of cloud service availability across 26 providers. Unlike provider status pages that may be slow to update or affected by their own outages, we offer unfiltered visibility into cloud performance through continuous testing from globally distributed agents.
Project Website: https://cloudlooking.glass - Visit for real-time dashboards and detailed availability reports.
Cloud Looking Glass is a graduate research project conducted through the Computer Science Department at Western Washington University by Jason Read and Dr. Tarek Idriss. Our mission is to empirically measure and publish real-world data on the availability and performance of hyperscale cloud platforms.
This methodology documentation describes our testing approach and data collection infrastructure:
Cloud Looking Glass uses two independent test accounts per cloud provider, labeled as 'com' and 'net' (account 1 and 2) in the dataset (these labels originate from the TLD of domain names we allocate to each account for managed DNS service measurements).
Cloud Looking Glass employs a multi-layered architecture to measure cloud service availability and performance across 26+ cloud providers globally. The system operates on a continuous 10-minute test cycle, executing millions of measurements daily to provide real-time insights into cloud control and data plane availability and performance. Detected events undergo manual review and classification before being documented as confirmed outages.
Universal tests are initiated independently by each Test Agent on their local schedule:
Distributed tests are centrally assigned by an external test scheduler and cover all other control plane, data plane, and networking measurements. These tests are executed once per account per 10-minute interval.
Since November 5, 2026, a stored RIPE Atlas failure must also pass three tighter checks: a probe that sent no packets, or that heard only from its own DNS resolver, says nothing about the target; the two attempts must come from different networks; and the other test network's run in the same round must not have reached the target, unless the failure repeats from different probes across two rounds.
Until November 4, 2026, a RIPE Atlas or Globalping test stored the result of its last attempt, whatever that attempt was. Most stored failures said nothing about the target: in the four days before the change, about 94% of 3,981 unsuccessful runs were a measurement whose result never reached Cloud Looking Glass, a refusal by the probe network, an API or client error, or a DNS query intercepted on the probe's own path. Since that change, a failure is stored only when an external probe ran the test and reported no answer, and a second attempt from a different probe reported the same in that run (a cloud source that names one tag may repeat on that tag). An attempt that answers wins over the others. A run with no result, or one failure that no second attempt confirmed, is discarded: it stores nothing, so it leaves a gap instead of a failure, and a daily check raises an alarm when a test family stores under 90% of its expected runs. Globalping reports total packet loss with a successful exit code, so such runs were stored as partial results, and a reply count that included the summary line let partial loss pass as success. Both are corrected. Runs from October 31, 2026 to that change that did not meet this rule were removed as test artifacts. The status ids are unchanged.
For each measurement, we capture three types of timing metrics:
measurements): The actual API request/response time, excluding SDK initialization and overhead. This is the closest measurement to what providers report in their SLA metrics and what you would experience with a warm, initialized SDK. Use this for comparing raw API performance across providers. Since November 8, 2026, when the last tests moved to warm connections (see Warm Connections for API Calls), it covers the request and the whole response on a connection already open, on every cloud; until its test moved, it covered a fresh connection to the API (DNS, TCP and TLS), the request and the whole response. Fetching a credential and signing the request are left out.measurements_cli): What the call would have read on a fresh connection: its connection's DNS, TCP and TLS setup plus the call, so the difference between measurements_cli and measurements is the setup a warm connection saves. Every test has called its cloud's APIs with curl on warm connections since November 8, 2026. Until its test moved, an AWS test's measurements_cli held the AWS CLI's own time for the call, read from its debug log with authentication included, and a Google Cloud test's was empty.measurements_wall): The total end-to-end execution time including all system overhead, process spawning, and cleanup. This is what you would measure with a stopwatch from command start to finish. Use this for capacity planning and understanding total resource consumption. Since November 8, 2026 it is curl's own process time on every cloud, its warm-up request included; until then an AWS test's was the AWS CLI's process.These distinctions are critical because different providers have vastly different SDK initialization times. For example, AWS CLI initialization can add 500-1000ms overhead, while lighter SDKs may add only 50-100ms. By separating these measurements, we can fairly compare the actual API performance independent of tooling choices.
Each HTTP test (http, https, httpb-100mb, httpsb-100mb) makes four requests, and each request time is one sample. Until the probe release of October 29, 2026 (testing resumed at 10:43 PM Pacific time), the probes also stored the three values of httping's summary line (the minimum, maximum and average of those four times) as samples, so each HTTP row held seven measurements instead of four. On six hours of production rows measured on October 29, 2026, this put the stored median 1.3% high on average (a mean absolute difference of 1.7-2.0%, about 4-5 ms), and 77% high at worst when a single request was slow. Rows recorded from that time on hold the four request times only. Earlier rows, and the test_status_* rollups built from their medians, keep the bias and were not rewritten, so HTTP medians that span the change can show a small step.
Until the probe release of November 1, 2026 that moved them (testing resumed at 11:12 PM Pacific time; the GCP probes, new that day, used the regional endpoints from their first results), CLG's Google Cloud Storage tests (gcp.gcs.<region>: http, https and httpb-100mb) reached each region's bucket through Google's global host, storage.googleapis.com. That name is anycast: a request entered Google's network at the front end nearest the test's source and crossed Google's backbone to the bucket, while a random query string on every request kept the front end from answering from its cache. Since that release, every location that offers a regional endpoint (42 of 43, the us and eu multi-regions included) is tested through it, storage.<region>.rep.googleapis.com, so a request enters Google's network in the bucket's region, as an Amazon S3 request enters AWS in its region. The asia multi-region has no regional endpoint and stays on the global host. Regional endpoints answer on IPv4 and over HTTPS only (port 80 is closed), so from that release (their plain-HTTP queue lines ended at 11:25 PM Pacific time) each regional location is tested with https and httpsb-100mb (the latter a new status id), and its http and httpb-100mb ids end; asia keeps all of its tests on the global host. The https ids keep their names, so their history shows a step at the change: the global host measured the distance to the nearest Google edge, the regional endpoint the distance to the region (to us-east4's bucket from one US workstation on November 1, 2026: a 7-14 ms connect through the global host, 70-83 ms through the regional endpoint).
Until the probe update of November 7, 2026 (10:59 PM Pacific time; one probe from 10:39 PM), the two-byte range tests (httpb-100mb and httpsb-100mb) did not read at a random place in the whole 100 MB object, as intended. Each request's offset came from one draw of bash's $RANDOM, which runs only from 0 to 32,767, so every read fell in the object's first 32.8 KB. On 12 hours of production runs measured on November 7, 2026, the range tests read 1.02 times http and 1.01 times https on the same targets (the median of the per-target ratios). Since that update, the offset is a 30-bit random (two draws) spread over the whole object. The status ids are unchanged, so a series whose reads now reach deep into the object may show a step at the change. In the eight hours after the update, Cloudflare R2 (cloudflare.r2, over https) showed that step: its range reads went from 1.21 to 6.87 times https on the same targets (a median of 213 ms before and 1,191 ms after), while the other services moved by about 5% or less. The same update widened the random query string that keeps a front-end cache from answering the Google Cloud Storage global-host and Cloudflare R2 requests: it had 32,768 possible values, and now has about a billion.
Until the AWS probe release of November 1, 2026 (com at 9:04 PM and net at 9:10 PM Pacific time; testing resumed at 11:12 PM), the Amazon S3 tests' copy step (copy-object-<class>) copied a 100 MB file (104,847,609 bytes) from the region's test bucket, and head-object-<class> and get-object-range-<class> then read that copy. Since that release they copy a 10 MB file (10,478,419 bytes), the size the Google Cloud Storage control plane tests copy (gcp.gcs.<region>--dp--copy-object-<class>), so the two clouds' copies are comparable. The smaller copy also keeps cheap the minimum storage duration that the infrequent-access and archive classes bill when an object is deleted early. The status ids are unchanged, so the copy-object-* history shows a step down at the change; the ranged GET reads the same 3 bytes either way.
Until the probe release of November 2, 2026 (testing resumed at 6:26 PM Pacific time), an AWS step that the AWS CLI retried after a refused attempt (a throttled or failed reply; the CLI makes up to three attempts) was timed from its first request to the first response the CLI parsed, so a retried success could carry the time of the refused attempt and of the retry's delay. Since that release, a step on every cloud is timed by the attempt that answered: the client's retry delays stay outside the measurement, and a retried step's stderr ends with CLG retries=N. From the same release every AWS call has a 10-second connect timeout and a 120-second timeout per attempt (the AWS CLI's defaults were 60 seconds each), and every Google Cloud call is retried up to twice, as the AWS CLI retries. The status ids are unchanged; only the values of retried steps change.
Until the GCP probe release of November 3, 2026 (testing resumed at 8:54 AM Pacific time), a Google Cloud call that curl retried after a refused reply whose body was not JSON (Google's HTML 502 error page) failed its step even when the retry answered, because the refused page sat before the answer in the step's output. Since that release such a step records the answering attempt, as every other retried step does. One step was affected before the fix (a Cloud Functions update in the net account at 5:02 AM Pacific time on November 3, 2026, removed as a harness failure).
Until the AWS probe release of November 2, 2026 (testing resumed at 6:26 PM Pacific time), the Amazon DynamoDB test's get-item step (aws.dynamodb.<region>--dp--get-item) made an eventually consistent read. Since that release it reads with strong consistency (--consistent-read), as every Firestore read is, so the two clouds' reads are comparable. A strongly consistent read uses twice the read capacity of an eventually consistent one. In the 1,926 runs of the eight days before the change, the eventually consistent read never returned a stale item. The status id is unchanged.
Until the AWS probe release of November 2, 2026 (testing resumed at 6:26 PM Pacific time), the Amazon DynamoDB test's table steps (aws.dynamodb.<region>--cp--create-kvtable, update-kvtable and delete-kvtable) waited for the table by running describe-table until its state changed, and stopped the clock when the last of those commands exited. That counted the last command's exit after its answer. The delete also took any failed read as the table being gone, not only the not-found answer. Since that release each step ends at the response of the read that first shows the state (ACTIVE, or not-found for the delete), as the AWS CLI's own log times it. Every wait now gives up after 300 seconds. The wait's own polls are unchanged (each poll's start-up still comes before its request), so the step times barely move: over the evening after the change their medians stayed within the steps' usual run-to-run spread of about 3 seconds. The status ids are unchanged.
Until the GCP probe release of November 2, 2026 (testing resumed at 6:26 PM Pacific time), the Firestore test's create step (gcp.firestore.<region>--cp--create-database) ended when Google's create operation reported done, which it does almost at once (806 ms at the median of the test's first runs). The new database then held its first write for about 4 seconds: put-document measured 4,176 ms at the median, against 118 ms for the read after it. Reads of the new database answered at their usual time (a live run on November 2, 2026). Since that release the create step also writes one document to the new database and ends when that write is answered, as the Amazon DynamoDB create step ends when the table reads ACTIVE. The document is then deleted, untimed, before the put. At the change create-database rose by about 2.7 seconds and put-document fell to its usual time (medians over the evening after the change: 3,757 ms and 127 ms, against 1,082 ms and 2,856 ms that afternoon). The status ids are unchanged.
Since the GCP probe release of November 2, 2026 (testing resumed at 6:26 PM Pacific time), a copy (gcp.gcs.<region>--dp--copy-object-<class>) that Cloud Storage answers in several rewrite calls counts the time of every call. Before it, only the first call counted. Every copy measured up to November 2, 2026 took a single call, so no earlier measurement is affected.
Until the probe release of November 2, 2026 (testing resumed at 6:26 PM Pacific time), the block storage tests' attach step (attach-volume-<tier>, on Amazon EBS and Google Cloud Persistent Disk) also timed a fio prefill of the new volume and a 3-5 second pause after it: on EBS gp2 and gp3 the prefill wrote the whole 1 GiB volume, on io1, io2, st1 and sc1 it ran for 15 seconds, and on Persistent Disk it stopped at its 20-second limit, so attach read 11-28 seconds where the attachment itself takes about 2 (EBS) to 5 (Persistent Disk). Since that release attach ends when the cloud reports the volume attached and the probe sees the device, and the prefill runs afterwards, untimed. EBS resize (update-volume-<tier>) and delete (delete-volume-<tier>) timed only the request (about 220 ms); they now wait until the new size is usable (the modification reads optimizing) and until the volume is gone, as the Persistent Disk steps always did. The four fio steps (rand-write-<tier>, seq-write-<tier>, rand-read-<tier>, seq-read-<tier>) now read and write the same prefilled 64 MiB at the start of the volume on every tier and both clouds. Before, the Persistent Disk prefill stopped at its 20-second limit, so most of its random reads fell on blocks the prefill had not written; its read latency did not change measurably with the prefilled region (pd-standard 0.7 ms before, 0.8 ms after). EBS detach is now a plain detach, as on Persistent Disk, instead of a forced one. On Amazon EFS, attach retries the mount every second instead of every 10 seconds, update (update-efs-<mode>) and delete (delete-efs-<mode>) wait until the change is applied and the file system is gone. The status ids are unchanged, so their history shows a step at the change.
EBS st1 and sc1 volumes charge each small I/O against their throughput budget as if it were 1 MiB, so their fio steps measure that pacing (about 30 ms per I/O on a 125 GiB st1 volume, 90-180 ms on sc1) rather than the device's latency. That is what a small-block workload sees on those tiers.
From that release until the probe release of November 2, 2026 (testing resumed at 10:15 PM Pacific time), the Amazon EFS fio steps were also capped at 100 I/O per second, like the block storage tests, and the cap raised the General Purpose read latency (rand-read-efs-gp from about 0.6 to 2.9 ms, seq-read-efs-gp from 0.7 to 1.0 ms): uncapped, each 5-second run re-reads its 10 MB test file several times, while the capped run's 500 reads touched most of its blocks once. The cap was then removed, so EFS reads measure as they did before November 2. Max I/O reads (about 3.3 ms) and every EFS write did not change. The EBS tests recorded no results from 6:30 to 7:20 PM Pacific time on November 2, 2026, while a missing permission held the new resize wait until it was granted.
Until the probe release of November 2, 2026 (testing resumed at 6:26 PM Pacific time), the AWS Lambda tests ran Node.js on the nodejs20.x runtime, and every Lambda runtime ran at Lambda's default 128 MB, while the Cloud Run functions test ran Node.js 24 at 256 MB. Since that release, Lambda runs Node.js 24 (nodejs24.x), and every Lambda runtime (Node.js, Python, Java, .NET and Ruby) runs at 256 MB on x86_64, the Cloud Run function's shape. Lambda's create and update now wait for the function's state with a deadline, polling back to back and stopping at the response that first reports it Active or updated. After an update, both clouds time the first invoke that the new code answers: an earlier answer from the old code is retried, untimed, about once a second for up to 30 seconds (before, the first invoke counted even when the old code answered it). The Cloud Run functions update now deploys new code, as Lambda's update-function-code does (before, it changed an environment variable, which also rebuilt the function), so both updates measure a code deployment, which on Google includes a Cloud Build. Cloud Run starts an instance while it deploys a function, so its first call after the create was already warm (77 ms against 33 ms for the warm invoke, where Lambda's first invoke is a cold start of about 320 ms against 44 ms). The release therefore ends gcp.functions.us-east4--dp--invoke-function-nodejs; the warm invoke, preceded by one untimed call, is the Cloud Run functions data plane status, and Lambda keeps its cold first invoke. The other status ids keep their names, so their history shows a step at the change.
Cloud Run functions publish no cold invoke. On November 5, 2026, a test function held its only instance busy and sent a second request, which Cloud Run answered from a new instance, but the request log could not show where start-up sat in that call: its latency leaves out the wait for an instance (a refused request waited 10.1 s and logged 0 s). On November 7, a probe instead compared each new instance's own process start with the moment the probe sent the request, on clocks bracketed to within 40 ms, and sent each request 5 seconds after the instance before it was held, so a spare started for the hold could not pass. All four samples it could bracket were cold starts triggered by the request, starting 184 to 424 ms after the latest moment of the send, and Google's logs agree with each. The run stopped at four of the ten samples its rule requires, because the probe's account may not delete the function's uploaded source. On November 9 the same check ran once more, in us-central1, with that source left to Google's own expiry rules and room for one more instance. Google's logs again show each of its seven measured calls as a cold start triggered by the request, but none passed the 50 ms clock bracket: since November 8 every Google Cloud call opens with an unsigned warm-up request in the same curl process, and the probe's clock window around the call now includes that warm-up's connection setup, so the brackets measured 66 to 181 ms. One of the two functions also answered a bracketing call from a spare instance, which ends a run. The result stays unproven: the Cloud Run invoke after an update keeps its name, and Lambda's cold first invoke stays unpaired.
Until the probe release of November 2, 2026 (testing resumed at 6:26 PM Pacific time), the Amazon SNS and Amazon SQS receive-message steps ran from just before the publish (or send) CLI process started to just after the receive CLI process exited, so two AWS CLI start-ups, about 1.5 seconds, sat inside a delivery time of a few hundred milliseconds (SNS read 1,948 ms at the median on November 2, 2026). SQS also sent its message with a 3 second delay and subtracted it afterwards. Since that release, delivery runs from the publish request's send to the response that carries the message, both read from the AWS CLI's own debug log, and SQS sends with no delay. A receive long-polls, up to 20 seconds per call, until the message arrives or 30 seconds pass, as Google Cloud Pub/Sub's pulls do. Pub/Sub's receive-message runs from the publish call's start to the end of the pull that carried the message (that pull's start plus curl's own time for it); before, it ended after the pull's process exited and its answer was read. SNS gains an unsubscribe step (aws.sns.us-east-1--cp--unsubscribe, a new status id), the counterpart of Pub/Sub's. SQS update-queue and delete-queue now wait until get-queue-attributes shows the change (SQS can take up to 60 seconds to apply either), where before they timed the request alone. The status ids keep their names, so the SNS and SQS receive-message history shows a step down at the change.
The SNS change rolled out on November 5, 2026 at 9:29:42 PM Pacific time on one canary and completed across all 26 probes at 9:49:43 PM. It starts its SQS receiver before publishing. Readiness records client pre-send intent, not proof that SQS accepted the receive request before publication. Delivery still runs from the publish API request's send to the response carrying the matching payload and SNS MessageId; receiver startup is excluded. The carrying receive attempt must have been pending across publish, and missing or inconsistent timing is rejected. Standalone SQS is unchanged. Pub/Sub still starts its pull after publishing and measures from publish-command construction to that pull's start plus curl's time. These receiver and clock boundaries differ, so the delivery values do not represent identical listener contracts.
A read after the final batch landed compared twelve complete ten-minute slots before the change (November 5, 7:20–9:20 PM Pacific time) with twelve after it (9:50–11:50 PM). Each service and test network contributed 12 runs per window; all 96 runs and their 768 commands succeeded, with no missing scheduled messaging sample. Delivery p50/p90 in milliseconds were:
| Service / network | Before p50 / p90 (ms) | After p50 / p90 (ms) |
|---|---|---|
| SNS com | 1014 / 1180.5 | 87 / 91.9 |
| SNS net | 1107 / 1248.5 | 86 / 93.9 |
| Pub/Sub com | 2345.5 / 2459.4 | 2370.5 / 2452.9 |
| Pub/Sub net | 2369 / 2485.1 | 2312.5 / 2395.4 |
Every delivery sample recorded one poll, and all 24 post-change SNS receives recorded client pre-send intent. Retry notes were absent, so actual retry counts are unknown from this extract. SNS receiver startup medians were 749 ms on com and 739.5 ms on net, outside the reported delivery interval. The baseline includes isolated messaging verification load in its first slot, and other wave files shipped at the same boundary. These small before/after samples describe the changed measurement contract; they do not establish a provider performance ranking or isolate a service-side improvement.
The probe release of November 7, 2026 (a hot patch: one canary per cloud at 5:09:44 PM Pacific time, every probe by 5:29:54 PM) gives standalone Amazon SQS and Google Cloud Pub/Sub the SNS receiver, started before the send or publish, and one delivery boundary for all three: from the send or publish request's client send stamp to the first response stamp of the receive that carries the message. AWS reads both stamps from the AWS CLI's debug log (milliseconds); Google Cloud reads them from curl's request trace (microseconds), a private file of which only the event lines are read. Readiness is client-side on both clouds: the AWS CLI logs a request before writing it (CLG readiness=client pre-send intent) and curl traces it once written (CLG readiness=client request written). Neither proves that the service accepted the receive request before the message was sent. The carrying receive must have been pending across the send, within 30 seconds, and carry the exact message (for SQS its MessageId and body; for Pub/Sub Google's message id, a per-run attribute and the data); otherwise the step fails, and SQS's fallback to wall-clock times is gone. Google holds an empty pull for about 19 seconds (ten traced pulls on November 7), so a pull that ended before the publish is started again before publishing. Every SQS, SNS and Pub/Sub send, publish and receive step now records its retries as CLG retries=N, 0 or unknown; before, a step with no retry carried no note, so its count was unknown. The status ids keep their names, so the SQS receive-message history shows a step down at the change.
A read after the 7:39 PM batch compared twelve complete ten-minute slots before the change (November 7, 3:10–5:10 PM Pacific time) with twelve after it (5:30–7:30 PM), leaving out the two rounds of the rollout. Each service and test network contributed 12 runs per window; all 144 runs and their 1,056 commands succeeded, with no missing scheduled messaging sample. Delivery p50/p90 in milliseconds were:
| Service / network | Before p50 / p90 (ms) | After p50 / p90 (ms) |
|---|---|---|
| SQS com | 1003.5 / 1285.1 | 49.5 / 74.8 |
| SQS net | 1030 / 1249.1 | 50.5 / 72.6 |
| SNS com (unchanged) | 88.5 / 105.8 | 87.5 / 97.3 |
| SNS net (unchanged) | 83 / 88.8 | 84 / 94.9 |
| Pub/Sub com | 2356 / 2469.5 | 2312.5 / 2408 |
| Pub/Sub net | 2347 / 2456.7 | 2306 / 2327.9 |
After the change, every delivery sample recorded one poll and every messaging step exactly one retries note, each of them 0. All 48 AWS receives recorded client pre-send intent and all 24 Pub/Sub receives client request written. The SQS drop is the receive CLI's start-up leaving the interval (receiver startup medians of 761 ms on com and 766.5 ms on net, now outside it), a change of method rather than of the service, which puts SQS on the footing SNS reached on November 5. SNS, unchanged, moved 1 ms at the median. Pub/Sub moved about 2% at the median under its new boundary, so its roughly 2.3 seconds is the time Google takes to deliver to a pull already waiting, not an artifact of the old clock. The send and publish steps moved at most 4 ms at the median. One other wave file (the Compute Engine boot test's SSH helper) shipped at the same boundary. These small before/after samples describe the changed measurement contract; they do not establish a provider performance ranking.
Until the probe release of November 2, 2026 (testing resumed at 6:26 PM Pacific time), the Amazon EC2 instance tests (aws.ec2.us-east-1--cp--create-instance-<os>, delete-instance-<os>) and the Compute Engine instance tests (gcp.gce.us-east4--cp--...) differed in four ways. The EC2 delete step ended when the instance reported shutting-down (about 2.8 s), while the Compute Engine delete waited until the instance was gone (105-107 s for Linux, about 133 s for Windows). EC2 launched in whichever Availability Zone it chose (us-east-1a or us-east-1c for 202 of 218 launches on November 2, 2026), while Compute Engine launched in the test probe's zone. EC2 launched whichever Amazon Linux or Windows image an unsorted image list named first (on November 2, 2026, an October 13 Amazon Linux image and a September 17 Windows image), while Compute Engine launched its image family's newest. And the two clouds' test VMs had different internet access: an EC2 instance had a public IPv4 address the probes never used plus IPv6 through its subnet, while a Compute Engine VM had none. Without internet access a Compute Engine guest stalls about 90 seconds while it shuts down, so most of its delete time was that stall: on November 2, 2026, VMs deleted side by side took 106.8 s with no internet access and 14.3 s with only an external IPv6 address.
Since that release, both clouds launch in the test probe's zone and subnet from the newest image (AWS's public SSM parameter for it, Google's image family), with no public IPv4 address and internet access over IPv6 (EC2 through its subnet, Compute Engine through an external IPv6 address). Both delete steps shut the guest down the normal way and last until the instance is gone (EC2 terminated), and both create steps check the guest's SSH or RDP port the same way, a connection attempt about every second from the test probe. The status ids are unchanged, so EC2's delete-instance-* history steps up and Compute Engine's steps down at the change. Running without a public IPv4 address does not slow the EC2 boot: three launches each way on November 2, 2026 finished booting in 6.4-7.1 s (Linux) and opened RDP within 1-3 s of each other on average (Windows).
Until the probe release of November 3, 2026 (testing resumed at 1:06 PM Pacific time), the Linux instance tests launched an AMD x86 instance on each cloud: Amazon EC2 a c7a.medium on Amazon Linux 2023, and Compute Engine a t2d-standard-1 on Debian 13. Neither boot was limited only by the cloud: the c7a.medium's single core held EC2's boot back by about a second (12.1 s against 11.0 s on a c7a.large on November 3, 2026), and on one core Debian 13 waited on the CPU and on Google's guest agent, which regenerates the SSH host keys before SSH may start (about 31 s against 25 s on four cores). Since that release, each cloud launches its cheapest instance type whose boot is not limited by its CPU or memory, on the provider's default general-purpose image: EC2 a c8g.medium (one AWS Graviton4 core, 2 GiB) on Amazon Linux 2023 arm64, and Compute Engine a c4a-highcpu-1 (one Google Axion core, 2 GB) on Debian 12 arm64, gcloud's default image family, with a Hyperdisk Balanced boot disk, the only kind C4A takes. On November 3, 2026, launched from a workstation, each booted within noise of its family's four-core size: 10.4 s for the c8g.medium against 10.4 s (c8g.xlarge), and 17.8 s for the c4a-highcpu-1 against 16.9 s (c4a-standard-4). The Windows instance tests keep their x86 instances, as Windows has no Arm build. The status ids are unchanged, so the create-instance-linux history of both clouds steps down at the change (about 12 to 10 s on EC2 and 32 to 18 s on Compute Engine), and the read, update and delete steps run on the new instances too.
A follow-up read on November 5, 2026 compared successful Linux probe runs from November 2 at 6:30 PM to November 3 at 12:10 PM Pacific time with November 4 at 1:00 PM to November 5 at 1:00 PM (184 before and 288 after per cloud, split equally between com and net). Compute Engine delete p50/p90 rose from 18.39/27.79 s to 21.43/34.34 s; the increase persisted on both test networks and in later-period and matched-time checks. EC2 delete changed from 21.32/27.06 s to 21.49/28.29 s, with no sustained increase established. The Compute Engine result varied by zone, including no increase in us-east4-a on net. These are observed changes across releases and workloads, not evidence that the instance shape alone caused them.
Since the probe release of November 7, 2026, Google Cloud's Hyperdisk block storage is tested on the Linux instance test's own c4a-highcpu-1 VM, since the e2-small test probes cannot attach Hyperdisk and C4A takes no other disk type. Each tier is its own block storage test, run around the VM in this order since the probe release of November 8, 2026 (testing resumed at 6:38 PM Pacific time): every tier's volume is created before the instance test's create step boots the VM; after the instance test's read and update steps, the probe opens SSH to the VM with a key made for that run alone, copies it a static fio 3.36 (the version the probes run), and runs each tier's attach, fio and detach on it, one tier at a time in a random order; and after the instance test's delete step, each tier's resize and delete run with the VM gone. Until that release, each tier's whole test ran on the VM in turn once its SSH port answered, before the instance test's read step. Since November 9, 2026, the volumes are created once the VM has booted, in the zone it booted in, before the instance test's read step. Since the November 11, 2026 probe deploy, the Hyperdisk Throughput volume (2 TiB, billed by the second) runs its whole test, from create to delete, at its turn on the VM, so it no longer waits for the instance's delete; the Hyperdisk Balanced volume keeps the order above. The Hyperdisk Balanced volume's delete step steps down at that release, since the volume is now deleted after the instance, a minute after its detach, rather than seconds after its detach from a running VM: from about 1.5 s to a median of 0.72 s (p90 1.86 s) over the first day in us-central1 (November 8, 2026, 11:03 PM to November 9, 11:03 PM Pacific time, 270 runs on both test networks). The step has two levels: most deletes take 0.47 to 0.8 s and about one in five takes 1.7 to 2.0 s, whether or not the VM is still running and whatever the order of the run, so the slower level is Google's own delete operation, not the probe; the p90 falls on it. A round whose VM does not launch, or cannot be reached or given fio, still runs each tier's control plane steps, and stores them with a note saying why (CLG host=unavailable reason=capacity, quota, launch, ssh or fio); no other instance type or zone is tried. The tiers are Hyperdisk Balanced at 6 GiB, the smallest size with its included 3,000 IOPS and 140 MiB/s (a 4 GiB volume gets 2,000 IOPS and cannot be resized by 1 GiB), and Hyperdisk Throughput at its 2 TiB minimum and lowest provisioned throughput, 20 MiB/s. Hyperdisk Throughput runs since the move to us-central1 (Google Cloud Test Region Moved to us-central1, below), whose disk quota holds its 2 TiB with room for a volume left behind by a failed delete; until then only Hyperdisk Balanced ran. Each tier has the Persistent Disk tests' steps, status ids (gcp.blockstorage.us-central1--cp--create-volume-hyperdisk-balanced, --dp--rand-read-hyperdisk-throughput and so on) and fio runs on the same prefilled 64 MiB. The probe makes every Compute Engine call, as for Persistent Disk and Amazon EBS. Attach and detach end when the operation is done and the VM has seen its device appear or go: the VM stamps that moment on its own clock, and both clocks are synced to Google's metadata server, so no SSH time is counted. The instance test's own steps and status ids are unchanged, and none of them times the Hyperdisk work. Its SSH key in the instance metadata did not move the boot: on November 7, 2026, 12 launches with the key against 12 without, interleaved in the com project, gave create medians of 18.58 s and 18.54 s. The instance test's delete step did move, faster: from November 4 to November 7, 2026 at 3:50 PM Pacific time, when Hyperdisk Balanced began, more than half of the Compute Engine delete-instance-linux runs took 27 to 34 s rather than about 19 s (p50 26.54 s, p90 33.95 s, 838 runs), and from then on none took more than 23 s (p50 18.63 s, p90 20.06 s over the first day, 288 runs, on both test networks). The VM now lives about two minutes longer before it is deleted, and we infer, without having proven it, that the slower deletes caught a guest still finishing its boot, which shuts down more slowly; the rise in delete time noted after the November 3 release went with it. The series steps down at that moment. As for Persistent Disk, Hyperdisk pairs with Amazon EBS as block storage, never tier to tier; Hyperdisk Throughput's IOPS follow its provisioned throughput, as EBS st1 and sc1 pace small I/O.
From November 9, 2026 (a hot patch), the latency of Google Cloud's Persistent Disk types (pd-balanced, pd-ssd and pd-standard) is the average I/O latency Google publishes for them (the io-latency-pd-<tier>-vendor series, read from disks that stay attached; see Provider-Published Latency, below), and CLG's own fio results for them no longer form a series. The disks the Persistent Disk tests create are attached for well under a minute, too briefly for a published figure of their own. Persistent Disk is Google's previous generation of block storage, and the probes keep testing it: its create, attach, detach, read, update and delete steps keep their status ids as its availability, and each fio run is still recorded with its test for troubleshooting, without a status id. The gcp.blockstorage.us-central1--dp--rand-write-pd-<tier>, seq-write, rand-read and seq-read series end at that date. Hyperdisk's fio runs on the Linux boot instance are unchanged and keep their own latency series.
Every Cloud Looking Glass test shows the best case a customer can get from the service, so a measurement that includes the test host's own delay reports the host, not the service. On a small or shared-core probe the delay that matters most is the probe's idle vCPU waking up for each reply or I/O completion. In November 2026 the storage tests where that delay was a visible share of the reading moved onto a dedicated-core host, the Linux instance test's own VM: Google Cloud Hyperdisk since November 7 (Hyperdisk on the Linux Boot Instance, above) and Amazon EBS and EFS since November 9, 2026 (below). Each moved series steps at the date its change went live. The network tests between the probes took the same delay out another way on November 8, 2026 (In-Zone Network Tests, below).
The same rules hold on both clouds. Only the host-sensitive steps run on the VM: attach, fio and detach (for a file system, the mount, fio and unmount). Each volume's control plane steps (create, read, resize, delete) are still made by the probe and timed as before. Most volumes are created before the tiers take the VM and are resized and deleted once the VM is gone. Since the November 11, 2026 probe deploy, the volumes billed by the second for what they provision (Amazon EBS io1 and io2, Google Cloud Hyperdisk Throughput) instead run their whole test, from create to delete, at their turn on the VM, so each lives about 50 seconds a round rather than about five minutes. Their steps still run one at a time with every other tier's, between the instance test's update and delete steps, and none of the instance test's own steps times them. The tiers run on the VM one at a time, in a random order each round, each with its own fill and cooldown, as the tests always have. A test may benefit from its own traffic but never from another test's, so the tiers' fio never runs together: measured on November 7 and 8, 2026, running them together moved their readings by up to 26%, mostly lower, and doubled some HDD readings. Attach and detach mean the same on both clouds: each runs from the API call until the cloud reports the operation done and the VM has seen its device appear or go, whichever is later, the VM stamping that moment on its own clock, placed on the probe's by their measured offset (0 when both follow the cloud's time service), so no SSH time is counted. Every VM runs the same static fio 3.36 build with the tests' own options.
A round whose VM cannot be launched or reached (no capacity, a quota, a failed launch, SSH or fio) still counts: each tier runs its control plane steps on the probe and stores them with the note CLG host=unavailable reason=<capacity|quota|launch|ssh|fio>. That round has no device reading for the tier, it is not an outage event, and the misses are counted weekly. The host type never changes silently: there is no fallback to another instance type or zone, since either would change the series, and a zone whose misses pass 5% of a week's rounds is reviewed by hand.
Since the round of 12:40 AM Pacific time on November 9, 2026, the Amazon EBS SSD tiers (gp2, gp3, io1 and io2) and both Amazon EFS file systems (General Purpose and Max I/O) are tested with the Linux instance test's c8g.medium VM as their host; until then each ran alone on a t4g.micro test probe, where on November 7, 2026 the same fio runs read 5-26% higher for the SSD tiers and 9-14% higher for EFS reads than on a c8g.medium. The instance test runs as one job, aws-ec2-linux-storage, queued first in each round and lasting about 7.8 minutes. Every volume and file system is created first, with the EFS mount targets, whose two waits (about 80 s each) are polled in turn rather than one after the other. The instance then boots and is read and updated. Before its delete, the probe opens SSH to the VM with a key made for that run alone (passed as cloud-init user data; the VM is in the probes' own security group), reads the VM's clock offset (Amazon Time Sync on both), copies it the static fio, and runs each tier there: an EBS volume attaches at its own device name, seen on the VM by its NVMe volume id, then is filled, measured and detached; an EFS file system is mounted over NFS 4.1 with efs-utils' default options, measured and unmounted. The instance is then deleted, and each tier's resize and delete run. Since the November 11, 2026 probe deploy, io1 and io2 are the exception: each is created, attached, measured, detached, read, resized and deleted at its turn on the VM, before the instance is deleted, so its provisioned IOPS are billed for about 55 seconds a round instead of about six minutes. Their detach-volume steps now take EBS's faster detach mode (about 7.5 s rather than 8.5 s) about half the time, as gp2's and gp3's do, against about one time in five before, so their mean detach fell 0.2-0.4 s. gp2, gp3 and EFS keep the order above. The probe makes every AWS call. The status ids are unchanged, and none of the instance test's own steps times the storage work: on November 8, 2026, eight launches each way, interleaved, gave create medians of 10.97 s without the tiers and 10.63 s with them.
Measured from a workstation on November 8, 2026 (eight rounds), the fio p50 on the VM read lower than on the probes: EBS gp2 by 9-20%, gp3 by 8-20%, io1 by 8-12% and io2 by 21-28%, EFS General Purpose reads by 22-26% and Max I/O reads by 9-11%. EFS writes, about 7-8 ms, are EFS's own and moved within 6% either way. EBS attach reads about 0.4 s faster (1.35-1.58 s against 1.87 s). EBS detach reads about 4 s slower (about 8.1 s against 3.6-4.1 s): all of the difference is EC2 reporting the volume available, after the VM had already released the device, and with the same tool an idle volume detached 4-7 s slower from a c8g.medium than from a t4g.micro, so this is EC2's own detach from a current-generation instance, which a customer there sees. The four detach-volume-<tier> series step up at the change. So do the two read-efs-<tier> series, by about 20 ms over the first day after the change (General Purpose about 44 to 66 ms, Max I/O about 43 to 62 ms): the call is the same DescribeFileSystems, sent by the probe over the same warm connection and answered with the same response, and all of the difference is EFS's own time to its first byte, now that the call follows the deletion of the VM that mounted the file system. EBS st1 and sc1 stay on the probes, since their fio steps measure their throughput pacing (Block and File Storage Timing, above), not the host.
Each probe measures the other probes of its region with tcping: the probes in its sibling zones (its own test network's) and, in its own zone, the other test network's probe (Same-Zone Network Targets, below). These readings are well under a millisecond, so until November 8, 2026 the probe itself was a large part of them. Three changes on that date took it out, with no change to the status ids.
Back-to-back probes. Since the hot patch of November 8, 2026 (one probe from the round of 8:20 PM Pacific time, every probe from the round of 8:40 PM), tcping sends its four probes back to back rather than one second apart, for every target. With probes a second apart, a small probe's vCPU halted between them and its wake-up read as latency. Measured from a workstation on November 8, 2026, back-to-back probes took 24-54% off same-zone readings on EC2 t4g.micro, Lightsail and Compute Engine e2-small probes, at no added CPU. They are the test's own traffic, so they follow the rule above. Each probe is still a fresh TCP handshake, and success and failure count as before. The TCP fallback some AWS regional tests run joined at 9:50 PM Pacific time that day. The disk tests cannot do the same, since they pace their I/O by design, so they moved to a dedicated-core host instead (above).
Kernel handshake round trip for probe-to-probe tests. Since the same hot patch, a tcping whose target is another CLG probe (same zone and cross zone, both clouds) stores the kernel's own round-trip measurement of each handshake (Linux TCP_INFO, tcpi_rtt) rather than the time the testing process waited in connect(). On November 8, 2026 the kernel's figure tracked a packet capture of the SYN and SYN-ACK within 0.006-0.025 ms, and it leaves out the probe waking its own process; the target's wake-up to answer the SYN is still in it. With back-to-back probes it read the same from a burstable probe as from a dedicated-core host: same zone on AWS, 0.207 ms from a t4g.micro (0.465 ms before) and 0.206 ms from a c8g.medium; on Google Cloud, 0.180-0.196 ms between two e2-small VMs in one project (0.625 ms before). The user-space connect time of the same handshakes stays in each run's recorded output.
Warm-up connects for probe-to-probe tests. Since the round of 3:00 PM Pacific time on November 15, 2026 (2:40 PM on one Azure probe), the kernel-RTT helper makes three untimed connects to the target probe before its four timed ones. A handshake over an idle path reads slower than one right behind another: measured on November 15, 2026 between Azure probes in Central US, a same-zone handshake read 0.26 ms back to back but 0.37, 0.61, 0.74 and 0.80 ms with 2, 10, 50 and 150 ms between connects, for IPv4 and IPv6 alike. A packet capture at both probes matched the kernel's figure within 0.02 ms and showed the target answering each SYN within 0.04 ms, so the time lies outside the measurement and the target's TCP stack: in the probes' own wake-up from idle or in Azure's network, which a capture inside the VMs cannot tell apart. Coming out of idle, Azure's IPv4 settled a connect or two later than its IPv6, so the median of four back-to-back connects read IPv4 0.12-0.15 ms above IPv6 (same zone 0.54 against 0.38 ms) while the fastest connect of each run showed no gap. On Google Cloud the first IPv4 connect read about 1 ms above the rest, which the median already left out; on AWS the first connect read a few hundredths of a millisecond high. Warm-up connects store no measurement, their failures count for nothing, each waits at most half a second, and the first that fails ends them. At the change (the median run over the two hours before against the first three patched rounds, IPv4 and IPv6), Azure same zone fell from 0.52 and 0.43 ms to 0.29 and 0.27 ms and cross zone from 0.83 and 0.71 ms to 0.63 and 0.65 ms; Google Cloud same zone from 0.18 and 0.19 ms to 0.14 and 0.15 ms and cross zone from 0.20 and 0.19 ms to 0.16 and 0.16 ms; AWS, already nearly flat, moved little: same zone from 0.30 and 0.29 ms to 0.26 and 0.29 ms, cross zone from 0.46 and 0.47 ms to 0.44 and 0.45 ms. Azure's IPv4 lead over IPv6, 0.09-0.12 ms before, is now within 0.03 ms either way, and the four timed connects of a run read alike. Azure notes that it treats ICMP differently from application traffic, so ping is no measure of a TCP or UDP round trip; CLG times every probe-to-probe path with TCP handshakes.
Google Cloud's two test networks are peered. A same-zone pair on Google Cloud is com's probe and net's, in two projects, and between projects Google carried even same-zone traffic over its external-address path, which added about 0.4 ms at the wire (0.70 ms, against 0.30 ms for two VMs in one project). Since the probe release of November 8, 2026 (testing resumed at 6:38 PM Pacific time), the two probe networks are peered for IPv4 and IPv6: same-zone IPv6 took the peering at once, and since the hot patch above a same-zone IPv4 test reaches the other probe at its private address over the peering, as an EC2 probe already reached its own network's Lightsail probe privately. AWS showed no comparable penalty between its two test accounts (cross-account IPv6 0.525 ms against 0.480 ms in one account), so its probes are not peered. The same release put the 64-bit build of the probes' tcping (Tcp-Ping/Tcping v0.1.1) on the x86 probes, Compute Engine and Lightsail, where the 32-bit build had read about 0.1 ms higher on Compute Engine.
The probe-to-probe series stepped down at these changes (median of the 10-minute p50s, com and net merged):
| Series | Before (ms) | After the peering, GCP (ms) | After the hot patch (ms) | Step |
|---|---|---|---|---|
AWS us-east-1 same-zone tcping4 | 0.428 | 0.249 | -42% | |
AWS us-east-1 same-zone tcping6 | 0.530 | 0.263 | -50% | |
AWS us-east-1 cross-zone tcping4 | 0.748 | 0.467 | -38% | |
AWS us-east-1 cross-zone tcping6 | 0.760 | 0.459 | -40% | |
GCP us-east4 same-zone tcping4 | 1.128 | 0.971 | 0.191 | -83% |
GCP us-east4 same-zone tcping6 | 1.107 | 0.558 | 0.195 | -82% |
GCP us-east4 cross-zone tcping4 | 0.995 | 0.942 | 0.540 | -46% |
GCP us-east4 cross-zone tcping6 | 0.955 | 0.905 | 0.529 | -45% |
On AWS, before is the 24 hours to 8:20 PM Pacific time on November 8, 2026, and after is 8:50 PM on November 8 to 8:10 AM on November 9 (about 11 hours, less the 10:07-11:03 PM testing pause). On Google Cloud, before is the 24 hours before the probe release, after the peering is 6:40-8:20 PM and after the hot patch 8:20-10:10 PM on November 8, when its tests left us-east4; those us-east4 series were removed from the dataset at the move (Google Cloud Test Region Moved to us-central1, below), so these figures are the record of the step. The us-central1 series started with all three changes in place: from 11:10 PM on November 8 to 8:10 AM on November 9, same zone read 0.199 ms (tcping4) and 0.244 ms (tcping6), and cross zone 0.849 and 0.835 ms, since us-central1's zones lie farther apart than us-east4's. Every other tcping from the AWS probes (services, other regions, other clouds) read about 0.07 ms lower from the hot patch: 5.5% for the series under 2 ms, and within the usual spread of the farther ones. For scale, Google's published same-zone median for us-east4-a was 0.223 ms (Provider-Published Latency, below); CLG's figures are its own measurements, which also show each path is up.
Until the probe release of November 2, 2026 (testing resumed at 6:26 PM Pacific time), a network test from an AWS EC2 probe to its own Availability Zone (for example aws.ec2.us-east-1.use1-az1--dp--tcping6--aws.ec2.us-east-1.use1-az1) measured up to three probes in that zone on every run and stored the fastest, so the host behind the measurement changed from run to run and the stored value leaned low. The same test from a Compute Engine probe measured one host, the other test network's probe in its zone. Since that release, every same-zone test measures one host by one rule and fails if that host does not answer: the other test network's probe of the same kind in the zone (an EC2 probe in aws-ping.com measures its counterpart in aws-ping.net; a Compute Engine probe in gcp-ping.com its counterpart in gcp-ping.net), at its public address. The EC2 probes have no IPv4 internet access, so their IPv4 same-zone tests measure the same network's Lightsail probe in the zone at its private address instead (about 0.4-0.8 ms, the host those tests already reached most often). When that address cannot be read (a freshly deployed Lightsail probe's web server can be stopped for a while), the IPv4 test is not run that round; until November 3, 2026 it was run over IPv6 instead and stored under the IPv6 test's status id. Cross-zone tests are unchanged on both clouds: the same network's probe in the other zone, over the private network. A Compute Engine same-zone test crosses from one test network's project to the other's over public addresses, so on Google Cloud it reads slightly slower than a cross-zone test (about 0.97 ms against 0.90 ms on November 2, 2026).
Until November 8, 2026, on Google Cloud, a same-zone test reached the other test network's probe at its public address, while a cross-zone test stayed on the private network path, so a Google Cloud same-zone result could read slower than its cross-zone results. Since then the two test networks are peered and a same-zone test takes the private path too (In-Zone Network Tests, above). AWS EC2 same-zone IPv6 tests also use the public path, and AWS same-zone IPv4 tests reach a Lightsail probe over the private path.
Until the probe release of November 4, 2026 (testing resumed at 10:19 AM Pacific time), four of the five Lightsail probes in the net test network ran in a different Availability Zone from the one they were named for, because Lightsail's zone letters do not follow the account's EC2 letters. Same-zone IPv4 results on net (tcping4 from use1-az1, az2, az4 and az6 to the same zone) therefore measured a cross-zone path, from 0.64 to 1.09 ms where the com network measured 0.40 to 0.52 ms. Results before that time stay as measured, and the status ids are unchanged.
Since November 4, 2026, S3 is also tested over HTTPS (https) and the Google Cloud Storage regional endpoints over TCP on port 443 (tcping4), so object storage in every region can be compared on the same protocol. The S3 http tests continue unchanged. Before that date, http to S3 and https to Google Cloud Storage read about 1.5 times apart, mostly from the TLS handshake.
Until the probe release of November 2, 2026 (testing resumed at 6:26 PM Pacific time), the Amazon Route 53 test's update-record step (aws.route53--cp--update-record) upserted the test record with the value it already held, so its wait for every name server to serve the change passed at once: it read about 270 ms, against about 6.4 seconds for create-record and delete-record. Since that release the upsert writes a new value and waits until every name server serves it (7.8 seconds in a live run that day). A zone is now created, and deleted, only when every one of its name servers answers its NS query (or none does), on Route 53 and Google Cloud DNS alike; before, each poll asked one name server picked at random. Route 53's read-record now lists only the test record, as Cloud DNS reads its one record set, and Cloud DNS no longer waits for its change to report done before it asks the name servers, since Route 53 never did. Waiting for every name server can now and then take minutes (one Route 53 create-record took 148.6 seconds in testing that day). The status ids are unchanged, so the update-record history shows a step up at the change.
Until the probe release of November 2, 2026 (testing resumed at 6:26 PM Pacific time), the Amazon CloudFront test's create-distro step (aws.cloudfront--cp--create-distro) polled the new distribution through the probe's DNS resolver. Its first poll came before the new *.cloudfront.net name existed, and the resolver kept that answer for cloudfront.net's 60-second negative cache, so every create read about 120 or 180 seconds (the daily median stayed between 120.7 and 121.2 seconds from October 20 to November 2, 2026). Since that release each poll looks the name up at cloudfront.net's own name servers and the servers they delegate the name to, then fetches through the address they give; a live run that day created in 95.2 seconds. update-distro disabled the distribution and waited until it stopped serving; it now changes the default cache TTL and waits until CloudFront reports the change deployed, as the Cloud CDN update changes its TTL. delete-distro repeated the update's time (160.5 against 161.3 seconds at the median); it now times taking the distribution out of service, from the disable's request through its deployment to the delete's answer, with no fixed pause. On Google Cloud, create-distro (gcp.cdn--cp--create-distro) now covers the CDN backend bucket, the host rule on the project's standing load balancer and the wait until the load balancer serves the test object, and delete-distro covers the host rule's removal and the bucket's delete, so the separate attach-distro and detach-distro steps end with this release and their ids are retired. Every CDN wait gave up after 420 seconds; since the probe release of November 15, 2026 (a hot patch, card aFc5G7AE), CloudFront's update and delete wait up to 15 minutes for the deploy, so a deploy slower than 420 seconds (about one run a day over November 8-15, 2026, on both test networks at once) is measured as its time rather than failing, and each run still ends by the close of the round after the one it began in. The other status ids keep their names, so their history shows a step at the change. With the probe release of November 3, 2026 the Google Cloud CDN control-plane test was retired (see Google Cloud CDN: Network Tests Only); CloudFront's continues.
Until the GCP probe release of November 2, 2026 (testing resumed at 6:26 PM Pacific time), the Agent Platform gpt-oss-120b test asked its prompts in us-central1 (gcp.aiplatform.us-central1--...-gpt-oss-120b), then the only region Google served the model in. Since that release it asks them on Agent Platform's global endpoint, as the other Agent Platform families are asked, under gcp.aiplatform.global--...-gpt-oss-120b; the us-central1 ids end, and their history stays in the rollups. Amazon Bedrock still serves gpt-oss-120b only in us-east-1, with no global inference profile, so aws.bedrock.us-east-1--...-gpt-oss-120b keep their region.
Until the GCP probe release of November 2, 2026 (testing resumed at 8:44 PM Pacific time), an Agent Platform prompt (gcp.aiplatform.global--dp--converse-<prompt>-<family>) was cut off after 120 seconds, as every call on both clouds is. Agent Platform's shared pools answer slowly at times: in the three days to November 2, 2026, Gemini Flash's slowest successful answer took 117.6 seconds, beside 7 prompts cut off at 120 seconds, and one gpt-oss-120b prompt received nothing in 120 seconds. Since that release a prompt may take up to 180 seconds, so a slow answer counts as a measurement rather than a failure; a prompt that stalls is still not asked again. Amazon Bedrock's prompts keep the 120-second limit, which they never came near (3.8 seconds at most). The status ids are unchanged.
Until the GCP probe release of November 3, 2026 (testing resumed at 8:54 AM Pacific time), an Agent Platform prompt that received nothing at all failed when its 180-second limit ran out, and it was not asked again. Google served one prompt, gpt-oss-120b's reasoning question from the net test network, from a backend that answers in under a second or not at all: it stalled 17 times between 8:54 PM on November 2 and 6:30 AM on November 3, 2026, and those failed runs were removed as test artifacts, as was one Gemini Flash stall. Since that release each attempt is limited to 120 seconds again, and a prompt that stalls is asked once more: its result is the attempt that answered, and its stderr ends with CLG retries=1. Two stalls in a row fail the step. Amazon Bedrock's prompts never stalled and are unchanged. The status ids are unchanged.
On November 3, 2026, the Windows instance tests ended on both clouds: Amazon EC2's (aws.ec2.us-east-1--cp--create-instance-windows, read-instance-windows, update-instance-windows, delete-instance-windows) and Compute Engine's (gcp.gce.us-east4--cp--...-instance-windows). They were retired to cut cost: each Compute Engine launch paid an hourly Windows Server license and spent about 3.6 minutes waiting for the guest's RDP port. Their ids end, and their history stays in the rollups. The Linux instance tests are unchanged.
Until the probe release of November 3, 2026, Cloud Looking Glass ran a Cloud CDN endpoint of its own in each Google Cloud test project: a load balancer serving a test bucket, which the network tests to gcp.cdn measured (cdn.gcp-ping.com) and the control-plane test added and removed a distribution on (gcp.cdn--cp--create-distro, read-distro, update-distro, delete-distro). With that release both load balancers and the control-plane test were retired: its ids end, and their history stays in the rollups. Since that release the network tests to gcp.cdn measure virustotal.com, Google's own site, served by a Google Cloud global load balancer with Cloud CDN over IPv4 and IPv6: ping and TCP connect from the probes, RIPE Atlas and Globalping, and an https request for its 256-byte robots.txt that counts any 2xx answer, since Cloud Looking Glass does not control that file's contents. The site redirects plain http to https, so the http test became an https test: aws.ec2.us-east-1--dp--http--gcp.cdn and gcp.gce.us-east4--dp--http--gcp.cdn end, and aws.ec2.us-east-1--dp--https--gcp.cdn and gcp.gce.us-east4--dp--https--gcp.cdn begin. TCP connect tests now use port 443 instead of 80. The other data-plane ids keep their names, so their history shows a step at the change of host.
Until the probe release of November 3, 2026, a control plane or AI prompt call that a provider refused for its request rate on every attempt (HTTP 429, Amazon's ThrottlingException, SlowDown, RequestLimitExceeded and their kin) failed its step, and the refusal could be stored as a measurement: on November 3, 2026, at 10:33 AM Pacific time, a gpt-oss-120b prompt on Google Cloud met "too many concurrent requests" on all three attempts, and its 328 ms refusal was stored as the prompt's time (that run was removed as a test artifact). Since that release a throttled call is asked again after waits of 10, 20, 40, then 60 seconds, each varied by up to a fifth, for as long as the run can still finish in its own 10-minute round. The step's result is the attempt that answered; the waits are not part of it, and its stderr ends with CLG throttled=N waited=Ns. A throttle that does not clear in time drops the whole run: its resources are deleted and nothing is stored, so a throttle never appears as a failure or an outage. A refusal for a provider's request rate is the shared capacity or the test's own pace, not the service failing. The status ids are unchanged.
Until a second probe release on November 3, 2026, two kinds of failed Google Cloud AI prompt were recorded with no further attempt. A prompt whose attempts were refused for their rate and whose last attempt then stalled had used up its retries, so it never got the one retry a stalled prompt is given. And gpt-oss-120b sometimes answered HTTP 200 with a finish_reason of abort, no text and no tokens after about 36 seconds, which no client retries because the call appears to have succeeded. Since that release a stall that follows a 429 is treated as a throttle, as above, and an aborted answer is asked once more after about 10 seconds. The step's result is the attempt that answered; the waits are not part of it, and an aborted prompt's stderr ends with CLG reasked=1. Two stalls in a row, or a second aborted answer, still fail the step. These two retries apply to Google Cloud's AI prompts alone, because asking a prompt again creates nothing; Amazon Bedrock's tests are unchanged. The status ids are unchanged.
Until the probe update of November 4, 2026 (finished at 12:09 AM Pacific time), the code prompt of every AI inference test asked whether a Python function generates "the Fibonacci sequence up to n", which can be read as the first n numbers as well as the numbers up to the value n. With reasoning off, GPT-6 Luna on Amazon Bedrock answered No on 17 of 260 repeated requests that evening, and its code prompt failed on 6 test runs from 5:40 PM to 9:40 PM Pacific time on November 3, 2026, all in the com test network (those through 9:00 PM were removed as test artifacts). Since that update the prompt asks whether the function generates "the Fibonacci numbers less than or equal to n", and is otherwise unchanged. GPT-6 Luna answered Yes on all 260 repeated requests to the new wording. Every model on both clouds is asked the same text, so the change applies to all of them. The status ids are unchanged.
Until November 3, 2026, a step that ended in an error after running for a measurable time stored that time as its result, instead of a failure: a Google Cloud AI prompt that stalled for 120 seconds stored 120 seconds as a latency, and that value reached the merged results and the rollups. Most steps that end in an error record no time and already stored a failure. Since that date every step that ends in an error stores a failure, as a failed step does, and counts as an event for its test network. A partly successful network test still stores its time, and a failure in one test network alone leaves the merged result to the other. The status ids are unchanged.
Until the probe update of November 4, 2026, every AI inference test sent the same bytes each time. On Google Cloud that made gpt-oss-120b stall in a way that stuck to one prompt on one test network, failing about half that prompt's runs for hours while every other prompt answered: Google routes such a request by its exact bytes, and about 8% of requests reach a path that never answers. The stuck prompt depended only on the bytes: adding a few spaces to the request moved a stall between test networks, and rewording a prompt moved it to that prompt. Since that update every prompt on both clouds carries a first line with a new random request id, which the model is told to ignore, and a Google Cloud prompt that stalls is asked once more with a new id instead of the same bytes. Two stalls in a row still fail the step. On November 4, 2026, the id changed no answer: 1,201 of 1,201 answered requests were correct across the Amazon Bedrock models, gpt-oss-120b and Gemini Flash, and gpt-oss-120b's median answer time stayed at 0.5 seconds. The status ids are unchanged, and test_commands.command now shows each request's id.
Until November 4, 2026, a test probe stored each batch of results one table at a time. If two probes' batches deadlocked, one table's rows were lost while the rest were stored and no error was raised: on November 4, 2026, at 7:39 AM Pacific time, 85 tests from one probe kept their commands but lost their targets, so they never reached the status tables. Two earlier deadlocks on November 2, 2026, lost rows the same way. Since this change a batch is stored whole or not at all, and a batch the database refuses is sent again at once. All three deadlocks paired an AWS probe with a Google Cloud probe, which held separate locks, so every probe now takes one shared lock. Separately, a failure to hand a test to a probe used to end that whole list of tests. At 8:10 AM Pacific time on November 4, 2026, the control server could not reach the Google Cloud probes for about two minutes, and about 2,650 tests did not run that round; the gap shows in the results as a missing round, not as a failure. A test that cannot be handed over is now asked again, tries the probe's IPv4 address, and is skipped alone if it still fails. The status ids are unchanged.
Until the probe release of November 4, 2026 (testing resumed at 12:58 PM Pacific time), the VPC and key-value update steps changed different settings on each cloud, so their results could not be compared. update-vpc turned on DNS hostnames on AWS and changed the routing mode on Google Cloud, and update-kvtable and update-database changed the table class on DynamoDB and the concurrency mode on Firestore. Since that release, update-vpc adds a subnet on both clouds, removed outside the timing before the delete step, and the two key-value steps turn on point-in-time recovery on both clouds, which DynamoDB turns off again outside the timing before its delete step. The status ids are unchanged, so these results change at that time. The AI control plane steps are not compared across clouds, because an Amazon Bedrock inference profile has no Google Cloud equivalent.
Since the probe release of November 8, 2026 (a hot patch), the Amazon DynamoDB test calls the DynamoDB API with curl instead of the AWS CLI, and times every call on a warm connection. Each call first opens its connection with an unsigned request to the same API host, whose answer is discarded, and the timed request reuses that connection. Its time therefore no longer includes the DNS lookup, the TCP connect or the TLS handshake. The handshake is CPU-bound, so it depended on the test probe rather than the service: on the probes it took 13 to 15 milliseconds on its own. Those phases are recorded beside each measurement, in the step's notes and in measurements_cli, which holds what the call would have read on a fresh connection. A table step that waits for its state now polls with calls of a few milliseconds, where each poll used to start a new AWS CLI process of about a second. The status ids are unchanged, so each DynamoDB series steps down at the change; the size of each step, measured once a day of results had come in, is given in the table below. The other AWS services follow one at a time, then Google Cloud's API calls and the HTTP and HTTPS network tests, each dated here. Amazon SQS and Amazon SNS followed on November 8, 2026 (a hot patch): their sends, publishes and receives are stamped by curl's own trace, in microseconds, where the AWS CLI's log gave milliseconds; the delivery boundary is unchanged. Where a test creates something and uses it at once, it now waits the second the AWS CLI's start-up used to put between the two calls, outside the timing: a new SQS queue waits the second AWS asks for, and SNS waits 2 seconds after granting its subscriber queue the right to receive before it publishes. Amazon S3 followed on November 8, 2026 (a hot patch). An S3 Express One Zone object call is signed with keys from the directory bucket's own session, opened by an untimed call before the step that needs it; a copy into a directory bucket is signed with the probe's own keys, as S3 Express requires. A new bucket waits a second before its first object is written, outside the timing. Amazon S3 Tables followed on November 8, 2026 (a hot patch): a new table bucket and a new namespace each wait a second before their first use, outside the timing. AWS Lambda followed on November 8, 2026 (a hot patch): a function's create and its code update are still timed to the poll that first shows the function ready, and each poll is now a warm call of a few milliseconds. Amazon Bedrock followed on November 8, 2026 (a hot patch): each prompt sends the same request as before, and the first prompt waits a second after its inference profile is created, outside the timing. A model timeout (HTTP 408, ModelTimeoutException), which the AWS CLI never retried, is now retried up to twice, as Google Cloud's prompts are: one that clears on a retry is timed by the attempt that answered and is no longer an event, and one that outlasts both retries still is. Each of the 11 model timeouts recorded on the AWS CLI, from March 2025 to August 2026, had failed its prompt on the first attempt. Amazon VPC followed on November 8, 2026 (a hot patch): the VPC's create is still timed to the poll that first reads it available, now a warm call of a few milliseconds; a new VPC waits a second before its first subnet, and the VPC's delete a second after its subnet's, outside the timing, since EC2's API is eventually consistent. Amazon EC2 instances followed on November 8, 2026 (a hot patch): the launch is still timed to the poll that first reads every instance running plus the wait for its SSH or RDP port, and the terminate to the poll that reads it terminated, each poll now a warm call; the newest image's id is read from AWS's public SSM parameter by an untimed call, as before. Amazon Route 53 followed on November 8, 2026 (the evening's probe release): each change to the test zone (a record change, the comment update, the delete) waits a second after the previous one was confirmed, outside the timing, since Route 53 refuses a change while the one before is still processing, which the AWS CLI's start-up used to wait out; the waits on every name server are unchanged. Amazon EBS followed on November 8, 2026 (the evening's probe release): a new volume waits a second after it reads available before it is attached, and the resize a second after the volume reads available again, outside the timing, since EC2's API is eventually consistent; the attach and detach steps still include the wait for the device to appear on (and leave) the probe, now measured to the millisecond, where it had been counted in whole seconds (0 or 1,000 ms). Amazon EFS followed on November 8, 2026 (the evening's probe release): the mount target's create, the throughput update and the file system's delete each retry a refusal that the file system is not ready or still in use (up to five more attempts, 2 seconds apart), timed by the attempt that answered, where the AWS CLI's start-up used to space them; the update now lasts until the file system reads available with its new throughput mode. Google Cloud's API calls followed on November 8, 2026 (the evening's probe release): every call a Google Cloud test makes is timed on a warm connection the same way, so its DNS, TCP and TLS handshake (15 to 25 milliseconds of CPU-bound setup on the Compute Engine probes) are left out of the measurement and kept beside it; a wait for a long-running operation is still timed on the probe's clock across its polls, as before. Amazon CloudFront followed on November 8, 2026 (the evening's probe release): each distribution is created with the configuration the AWS CLI built for it, element for element, and its waits still poll about once a second, as the CLI's did (measured in CloudTrail on November 8, 2026); the checks that the distribution serves are unchanged. The HTTP and HTTPS tests followed on November 8, 2026 (the evening's probe release): each run opens one connection with a warm-up request to the target's host and times its four requests on it, so a sample no longer includes the DNS lookup, the TCP connect or, over HTTPS, the TLS handshake, whose round trips had made each HTTPS sample to a distant target several times a single request's time. The warm-up's phases are kept in the step's notes, and the 100 MB range tests are timed the same way. The status ids are unchanged, so every HTTP and HTTPS series steps down at the change, HTTPS the most. On November 8, 2026, once the HTTP and HTTPS tests ran on warm connections, the 140 targets that read their 100 MB range test over plain HTTP (httpb-100mb) moved it to HTTPS (httpsb-100mb), as every other range target already read it. Each target's httpb-100mb history was renamed httpsb-100mb, so its series continues across the change, over HTTP before that date and HTTPS after; the two-byte read is otherwise unchanged, and the TLS handshake stays out of it, paid once in the untimed warm-up.
The size of each step was measured once a day of results had come in, per status id, as the change in the id's median, and is given below as the median over each group's ids. For the API calls, the before is each test's 24 hours on the AWS CLI before its first curl run, and the after its curl runs up to the probe deploy of 5:39 PM Pacific time on November 9, 2026, both networks counted. For the HTTP and HTTPS tests from AWS us-east-1, the before is the 10-minute rows from 5:25 PM on November 7 to 5:25 PM on November 8, and the after those from 6:40 PM on November 8 to 5:40 PM on November 9, 2026. A timed call is one request; a wait polls until its resource reaches a state (3 seconds or more on either side), and a whole-process step is one the AWS CLI timed as its whole process, since its log held no wire time for it. Across the services, the connection setup a warm call now leaves out of its time was a median of 13 to 18 milliseconds per call on the AWS probes.
| Tests (switched November 8, 2026) | Status ids | Before / after per id | Timed calls: median step | Waits and whole-process steps: median step |
|---|---|---|---|---|
| Amazon DynamoDB | 8 | 272 / 284 runs | −18.9 ms (−54%), 6 ids | −425 ms (−5.7%), 2 ids |
| Amazon SQS | 4 of 6 | 272 / 285 runs | −17.4 ms (−38%), 2 ids | −940 ms (−91%), 2 ids |
| Amazon SNS | 6 | 272 / 286 runs | −18.3 ms (−18%) | none |
| Amazon S3 | 31 | 271-815 / 284-854 runs | −22.8 ms (−37%) | none |
| Amazon S3 Tables | 8 | 274 / 260 runs | −16.6 ms (−8.8%) | none |
| AWS Lambda | 35 | 274 / 260 runs | −13.9 ms (−6.1%), 25 ids | −395 ms (−16%), 10 ids |
| Amazon Bedrock | 40 | 286-288 / 267-269 runs | −9.9 ms (−6.4%) | none |
| Amazon VPC | 4 | 272 / 260 runs | −11.9 ms (−4.2%), 3 ids | −1.15 s (−63%), 1 id |
| Amazon EC2 instances | 4 | 274 / 260 runs | −18.7 ms (−9.9%), 2 ids | +407 ms (+3.6%), 2 ids |
| Amazon Route 53 | 8 | 274 / 260 runs | −19.9 ms (−33%), 3 ids | +290 ms (+4.6%), 5 ids |
| Amazon CloudFront | 4 | 283 / 266-268 runs | −14.9 ms (−17%), 1 id | +3.1 s (+1.9%), 3 ids |
| Amazon EBS st1 and sc1 | 12 | 272 / 260 runs | −58.1 ms (−39%), 2 ids | −416 ms (−14%), 10 ids |
| Amazon EBS gp2, gp3, io1 and io2* | 24 | 274 / 60 runs | −56.4 ms (−37%), 4 ids | −407 ms (−13%), 20 ids |
| Amazon EFS* | 12 | 274 / 59-60 runs | −17.9 ms (−29%), 2 ids | −658 ms (−25%), 10 ids |
| Google Cloud Agent Platform and Cloud DNS (global)† | 24 | 281-288 / 41-42 runs | −20.0 ms (−16%), 9 calls under 0.5 s | −37.2 ms (−2.1%, within run-to-run noise), 15 creates and prompts |
| HTTP from AWS us-east-1 | 149 | 144 / 130 rounds | −104 ms (−50%) per request | not applicable |
| HTTPS from AWS us-east-1 | 209 | 144 / 130 rounds | −229 ms (−66%) per request | not applicable |
| HTTPS 100 MB range from AWS us-east-1‡ | 59 | 144 / 130 rounds | −198 ms (−62%) per read | not applicable |
* The EBS SSD tiers and both EFS file systems moved to the Linux instance test's VM at 12:40 AM Pacific time on November 9, 2026 (see above), so their after is their curl runs on the probes before that move, from 6:40 PM on November 8. Amazon SQS's two message-delivery steps are left out of this comparison.
† Run from the us-east4 probes on both sides (after: 6:40 to 10:07 PM on November 8, 2026). The regional Google Cloud services (Cloud Storage, Firestore, Pub/Sub, Compute Engine, Persistent Disk, Hyperdisk and the functions) and Google Cloud's HTTP and HTTPS tests have no measured step: their us-east4 history was removed when the region was retired, and the us-central1 ids have no before.
‡ The 140 range targets from this source that moved from HTTP to HTTPS on November 8, 2026 are left out, since their before was read over plain HTTP.
Three kinds of wait rose slightly: CloudFront's distribution create, update and delete (+1.5, +4.9 and +3.1 s, 2-6%), Route 53's zone and record changes (+230 to +500 ms, 4-8%) and the EC2 Linux launch (+0.7 s). Each of these steps polls until a state is reached, and the waits curl added between calls are outside the timing, so the rise most likely comes from where each poll now lands rather than from the service itself.
Since the round of 8:50 AM Pacific time on November 10, 2026, the plain HTTP request test (http) is retired for the 146 targets that also answer over HTTPS, and each keeps its HTTPS test (https). On warm connections the two had measured the same thing: over 144 rounds (24 hours) from each test source, AWS us-east-1 and Google Cloud us-central1, their medians agreed within 1 millisecond or 5% for 287 of the 292 pairs, and the five that differed did so through the target's own spread rather than the protocol (read on November 9 and 10, 2026). The three targets that answer only over plain HTTP (the Alibaba Cloud, Fastly and Tencent Cloud CDNs) keep their http test. The retired http ids keep their history in the rollups, and each retired target's TCP test stays on the port it used before.
Since November 9, 2026 (a hot patch: 2:29 PM Pacific time on com, 2:49 PM on net), the Google Cloud Firestore test makes its document calls (put-document, get-document, update-document, delete-document, and the untimed write that shows a new database takes writes) to Firestore's regional endpoint (firestore.us-central1.rep.googleapis.com), which Google always serves in the region it names, instead of its global one; the database's own calls stay on the global endpoint. Timed by hand from the us-central1 probes on November 9, 2026, each document call took 3.8 to 5.5 milliseconds more than Google's own figure for it on the regional endpoint against 4.7 to 10.0 on the global one. The status ids are unchanged, and the four document series stepped down at the change: over the same night hours (11:10 PM to 7:00 AM Pacific time) the night before and the night after, their medians fell by 13.3 to 36.2 milliseconds (get-document 51.3 to 34.3 on com and 52.7 to 39.4 on net; put-document 88.7 to 64.0 and 106.2 to 70.0; update-document 82.4 to 63.2 and 82.8 to 63.1; delete-document 70.1 to 56.8 and 81.8 to 63.9), and Google's own figure for the same calls fell by 5 to 15 milliseconds over the same hours.
From the same hot patch until November 10, 2026 (a hot patch: 8:40 AM Pacific time; 8:20 AM on one com probe), the Google Cloud Pub/Sub test also made every call to Pub/Sub's regional endpoint (pubsub.us-central1.rep.googleapis.com); before and since, it uses the locational endpoint (us-central1-pubsub.googleapis.com). By hand, repeated publishes to one topic took 24.0 and 22.6 milliseconds (median, com and net) on the regional endpoint against 36.2 and 33.5 on the locational one, but the test publishes once to a topic it has just created, and that first publish was slower on the regional endpoint: over the same night hours the publish series rose from 52.3 to 57.9 milliseconds on com and from 53.3 to 60.6 on net, while Google's own figure for it rose from 24.7 and 27.2 to 35.6. The test went back to the locational endpoint, which gives the better result for what it measures. In the same morning hours (8:30 to 10:50 AM Pacific time) after the return, the series read 63.5 and 59.9 milliseconds against 60.8 and 60.2 on November 9, its level before the change; the results between the two patches stay in the series.
Until 9:59 PM Pacific time on November 7, 2026, each rollup level coarser than 10 minutes (test_status_1m through test_status_daily) was built from the latest slots of each status id's 24-hour result buffer in test_status, as if slot N were the round N rounds ago. A buffer gains a slot only when a result arrives, so a round with no result for a test network (a testing pause, or a test dropped or finishing late) shifted the slots, and the coarse row also read results from before its own interval. An event near the end of one interval could be counted again in the next, without its outage record, and latency statistics could include values from the previous interval. Since then each coarse row is built from the test_status_1w rows inside its interval: its events are the sum of theirs, and its latency and standard deviation statistics are taken over each 10-minute row's median and standard deviation. Where no round was missing, this matched the earlier values within 1% for about 99% of rows. A 10-minute row also counts a test network's failure only in the round its result arrived in. Rows found double counted from October 31, 2026 on were corrected; every rollup event before that date had been purged or documented one by one in the review of November 4, 2026.
Since the probe release of November 8, 2026 (testing resumed at 11:03 PM Pacific time), Cloud Looking Glass's Google Cloud probes and tests run in us-central1 (Council Bluffs, Iowa) instead of us-east4 (Ashburn, Virginia), with one e2-small probe in each of its four zones, a, b, c and f, in each test network, where us-east4 had three. us-central1 is Google Cloud's largest region, as us-east-1 is AWS's, so each cloud's home region is now its largest rather than the two sharing one metro: a network test that both clouds' probes run to the same target starts from Virginia on AWS and from Iowa on Google Cloud, and its results differ by that distance. The probes' results record their geography as the United States, Iowa, north-america.us-midwest.
Every Google Cloud series restarted under its us-central1 status id (gcp.gce.us-central1--dp--tcping4--aws.s3.us-east-1, gcp.blockstorage.us-central1--cp--create-volume-pd-ssd and so on), and the us-east4 series, their results and their outage records were removed from the dataset. Two kinds of series name no region and carry on: the Cloud DNS tests (gcp.dns--cp--create-zone and so on) and the AI tests (gcp.aiplatform.global--...). The AI prompts already went to Google's global endpoint, but each AI test's control plane steps create, read, rename and delete an empty endpoint in the probe's region, so those four series step at the move. The same-zone and cross-zone network tests now pair four zones: 32 status ids, where us-east4 had 18.
Hyperdisk Throughput joined the Linux instance test at the move, since us-central1's disk quota holds its 2 TiB with room for one volume left behind by a failed delete. Before each Throughput run, the probe deletes, outside the timing, any of its own Throughput volumes that a failed delete left in the region more than 15 minutes earlier. The dedicated-core Compute Engine VM prepared for the Persistent Disk tests on November 8, 2026 never ran and was removed; the Persistent Disk tests stay on the probes. For Google's published latency of each Persistent Disk type, each test network's zone-a probe carries a 10 GiB pd-ssd and a 10 GiB pd-standard volume of its own that read and write a little every minute (1 second of 4 KiB I/O at 100 operations a second, skipped in each round's minute :x9), since Google publishes a disk's latency only for minutes in which it does I/O; the probes' pd-balanced boot disks give that type's figure.
Since November 9, 2026, 7:09 AM Pacific time (a hot patch), the Linux instance test's VM and the Hyperdisk volumes tested on it launch only in us-central1-b or us-central1-f, whichever zone the probe running the test is in: the two zones take turns round by round, and both test networks use the same zone in a round. After the move, c4a-highcpu-1 was out of stock in us-central1-a for almost every launch (2 of 77 succeeded by 6:30 AM Pacific time on November 9) and in us-central1-c from about 1:30 AM that night, while us-central1-b and us-central1-f launched every time. The create step's record names the zone, the status ids are unchanged, and a zone that has no capacity still fails its round on both test networks, with no other zone tried.
Since November 9, 2026, 9:50 AM Pacific time (a hot patch), a launch that Google refuses for lack of capacity (a stockout) is tried again in the same run in the next zone: the round's zone, then the other of us-central1-b and us-central1-f, then us-central1-a, then us-central1-c, each move starting within 60 seconds of the first try. The create step measures only the launch that succeeded, and its record names each zone that was out (CLG capacity=stockout zone=us-central1-f). A zone that is out is a capacity note, not an event; only a round in which every zone is out fails. Since the VM's zone is known only once it has launched, the Hyperdisk volumes are now created right after the instance test's create step, in the VM's zone, instead of before it. The gcp.blockstorage.us-central1--cp--create-volume-hyperdisk-balanced and create-volume-hyperdisk-throughput series may step at that time, and the instance test's read, update and delete steps now run a few seconds later in the VM's life.
Cloud Looking Glass's Azure probes run in Central US (Des Moines, Iowa), one in each of its three availability zones in each test network. The two test networks are separate Azure accounts, each its own tenant and subscription with its own sign-in and billing, as on AWS and Google Cloud. Each probe is a B2pls_v2 virtual machine (2 Arm vCPUs, 4 GiB of memory, a 30% baseline per vCPU with burst credits) running AlmaLinux 10, on a Standard SSD boot disk, with accelerated networking, a static public IPv4 and IPv6 address, and the same probe software, boot steps and 8 test workers as the Google Cloud probes. Central US was chosen when East US 2, the first choice, granted no quota for this size on November 13, 2026; its probes record their geography as the United States, Iowa, north-america.us-midwest, and lie about 200 km from Google Cloud's us-central1 probes.
Azure numbers a subscription's zones differently for each subscription: com's zone 1 is the physical zone centralus-az1, while net's zone 1 is centralus-az3. The probes are named, and their results recorded, by the physical zone (centralus-az1.centralus.vm.azure-ping.com, status ids beginning azure.vm.centralus.centralus-az1), so a same-zone test between the two networks pairs probes in the same building. The two networks are separate tenants. Since the probe release of the night of November 14, 2026, their probe networks are peered across the tenants, so a probe reaches the other network's probe in the same zone at its private addresses (below).
Azure translates a virtual machine's public IPv6 address the way it translates IPv4, so the machine itself holds only a private IPv6 address. Each Azure probe therefore publishes its public IPv6 address in its ipv6.txt file and records it as its own address in each result, as the AWS and Google Cloud probes do with the address on their interface. Azure's network security groups pass ping over IPv4 only, so unlike the AWS and Google Cloud probes, the Azure probes do not answer ping over IPv6; no Cloud Looking Glass test pings them over IPv6, and their own IPv6 tests are unaffected.
Since the round of 9:10 PM Pacific time on November 13, 2026, the Azure probes run the same network test lists as the AWS and Google Cloud probes, in both test networks, at the same minute of each round, and carry their share of the RIPE Atlas and Globalping lists. Their results are recorded under azure.vm.centralus (for example azure.vm.centralus--dp--tcping4--aws.s3.us-east-1), beside aws.ec2.us-east-1 and gcp.gce.us-central1.
Since their first round (5:42 PM Pacific time on November 13, 2026), each Azure probe also measures the other probes of Central US with tcping, as on the other clouds (In-Zone Network Tests, above), timed by the kernel's handshake round trip (azure.vm.centralus.centralus-az1--dp--tcping4--azure.vm.centralus.centralus-az2 and so on, 18 ids in each test network). Across zones a probe measures its own network's probe, and in its own zone the other network's probe. Until the night of November 14, 2026, a same-zone pair crossed both networks' public addresses, IPv4 and IPv6, and every IPv6 pair took the public path, since Azure translates a VM's public IPv6 address as it does IPv4 and the VM holds only a private one. That path cost about 0.3 ms: in a rehearsal on November 13, 2026, two VMs in one zone of one subscription read 0.272 ms over private IPv4 against 0.52-0.60 ms over public IPv4 and 0.55-0.57 ms over public IPv6. Over the first hours (6:00-10:20 PM Pacific time on November 13, 2026, com and net, the median of the runs' medians) same zone read 0.665 ms (tcping4) and 0.725 ms (tcping6), and cross zone 0.817 and 0.875 ms; Google Cloud's peered same-zone pairs read about 0.2 ms. Since the probe release of the night of November 14, 2026, the two networks' probe networks are peered across their tenants, IPv4 and IPv6, and every probe-to-probe test reaches its target at a private address: IPv4 from the target's own address file, as on Google Cloud, and IPv6 from a second file holding the VM's private IPv6 address (/ipv6-vnet.txt).
The region target azure.centralus, which the Globalping lists measure from outside Azure, is the zone-1 probe of each test network (centralus-az1, at its static public addresses), since Azure Blob Storage, the other Azure target in the region, does not answer ping. Central US lies about 200 km from Google Cloud's us-central1 probes.
The Azure Blob Storage network targets (azure.storage.<region>, one storage account in each of 42 regions) answer over IPv4 only (no AAAA record) and drop ICMP, so they are tested with tcping4 on port 443, https and httpsb-100mb, and never with ping or over IPv6. Each test network reads its own accounts, as on AWS and Google Cloud: net's are clgnet<region> in the net subscription, filled with the same 33 test files as com's clg<region>. The Azure probes read them from their first round; the AWS and Google Cloud probes in net since November 14, 2026, 12:09 AM Pacific time (a hot patch; one AWS net probe since 11:49 PM on November 13), and until then read com's accounts. Azure refused a new account in West Europe to the net subscription (RequestDisallowedByAzure, November 13, 2026), so both networks read com's clgwesteurope. The status ids keep their names, so net's series may step at the change.
Azure's control plane tests run in Central US (Des Moines, Iowa), in both test subscriptions, from their first round. Like the Google Cloud tests, every step is a call to Azure's REST APIs with curl on a warm connection, signed with a token from the test probe's own managed identity, and each step that starts a change in Azure Resource Manager waits for that change's operation to report success. The steps follow the cross-cloud measurement contract above, and each test pairs with its AWS and Google Cloud counterparts at the service level.
The Linux instance test (azure.vm.centralus--cp--create-instance-linux and its read, update and delete steps) launches a B2pts_v2 VM (2 Arm vCPUs, 1 GiB) on Debian 12 with a Standard SSD boot disk, in one call that also creates its network interface, a public IPv6 address for outbound traffic, and the disk. The create step ends when the operation succeeds and the VM answers on port 22; the delete step ends when the VM is gone. The size and image were chosen by measurement on November 13, 2026: Debian 12 booted fastest of the five Arm images tried (Ubuntu 24.04 server and minimal, Azure Linux 3, Debian 12 and 13), and the second test subscription cannot run any D-series Arm size in Central US. Unlike the AWS (c8g.medium) and Google Cloud (c4a-highcpu-1) instance tests, Azure's runs on a burstable size: in the first subscription a D2pls_v6 VM reached SSH in a median 22.8 s against B2pts_v2's 28.2 s (Debian 12, Central US, November 13, 2026, 3:17-3:40 PM Pacific time), so part of a gap in create-instance times is the host class, not Azure being slower. The managed disks tested on the same VM are not affected: on November 14, 2026, Premium SSD, Premium SSD v2 and Standard SSD read the same from a B2pts_v2, a dedicated-core D2pls_v6 and an x86 D2als_v6 with an NVMe disk controller (median of five runs of the test's own fio steps; Premium SSD random reads 1.97, 2.08 and 1.97 ms), with no CPU steal on any of them. A launch Azure refuses for lack of capacity (ZonalAllocationFailed, AllocationFailed, SkuNotAvailable or OverconstrainedAllocationRequest) is tried again in the same run in another of the region's three zones, and such a refusal is never counted as an event. A Windows Server variant is registered but not queued, as on AWS and Google Cloud.
Azure's managed disks are tested on that VM, as Google Cloud's Hyperdisk is: Premium SSD v2, Premium SSD and Standard SSD, each at its 4 GiB minimum (azure.disk.centralus--cp--create-volume-premium-ssd-v2, --dp--rand-read-standard-ssd and so on), with the same steps, fio runs and prefilled 64 MiB, attach and detach ending at the VM's own device stamp. Ultra Disk is built and registered, but runs only if a day of metered runs shows it costs at most $5 a month a subscription. Block storage pairs as a service, never tier to tier. Premium SSD and Standard SSD read about 1.3-2.1 ms on every host tried, against 0.4-0.7 ms for EBS gp3 and Hyperdisk Balanced: that difference is the disks' own. Of Azure's tiers, Premium SSD v2 is the most similar to gp3 and Hyperdisk Balanced (performance set apart from size), a suggestion rather than a pair. Since November 14, 2026, the prefill uses the same fio options on all three clouds.
Azure Files is tested over NFS 4.1 (azure.files.centralus--cp--create-share-nfs and so on), paired with Amazon EFS: a 32 GiB share in a storage account made for the round, mounted on the same VM, with the mount and unmount timed on the VM's own clock and retried each second, and the same fio runs on a file in the share. The account is made before the share's steps, untimed, as EFS's mount target is, and the VM's NFS client is installed untimed before the mount (Debian 12's Azure image has none). SMB shares are not tested. Like Ultra Disk, the Files test runs only once a day of metered runs has shown its cost.
Azure Blob Storage is tested in its hot, cool and cold tiers (azure.storage.centralus--dp--put-object-hot and so on), paired with Amazon S3 and Google Cloud Storage. Azure's equivalent of a bucket is a storage account with a container, so the control plane steps create, read, update and delete the account and create its container, and since November 14, 2026 delete the empty container before the account (azure.storage.centralus--cp--delete-container). The container's create and delete are the like-for-like counterparts of a bucket's; the account's steps (about 19 seconds to create) have no counterpart on the other clouds; the data plane steps are Google Cloud Storage's, and the copy is a server-side copy of the region's 10 MB test object. The archive tier, which is offline, is not tested. Blob's public endpoints answer on IPv4 only (their names have no IPv6 address, read November 13, 2026), so the probes reach Blob over IPv4, and the test accounts accept HTTPS only.
The Azure probes run the same control-plane tests as AWS and Google Cloud for databases, functions, messaging, DNS and AI inference, each paired with the other clouds at the service level, never product tier to product tier. Every call is a REST request with curl on a warm connection, signed with an Entra token from the probe's own managed identity; no Azure CLI runs on a probe. Each round's resources are made in the test network's own test resource group, named clg-<kind>-<10 hex> and tagged with the test and run, and deleted by the test itself; the orphan sweep removes any a failed run leaves after 24 hours. Where a service needs a standing parent (a Cosmos DB account, a storage account, a Service Bus namespace, a Foundry account), one per test network stands, and each round makes its children in it.
Cosmos DB (azure.cosmosdb.centralus, beside DynamoDB and Firestore): the account is serverless, single-region and Strong by default, so a point read is strongly consistent like the other clouds'. Each round creates a container (Cosmos's unit of data, the closest match to a table), done when its Resource Manager operation succeeds and the data plane takes a write; then puts, reads, patches and deletes one item over the data plane, reads the container, sets its default TTL (point-in-time recovery, which the other clouds' updates turn on, is an account setting on Cosmos) and deletes it until it answers 404. Each item step notes the request units it cost.
Functions (azure.functions.centralus, beside Lambda and Cloud Run functions): Node.js 24 on the Flex Consumption plan, 512 MB (Flex's smallest; the other clouds run 256 MB) and one instance. The create covers the plan, the app and a deployment of the code package, ending when the deployment reports success; the update deploys new code; the first call after each deployment is retried while the host loads the package and timed by the call that answered. The function answers its worker's start time, and the warm call brackets the clock offset, so each run notes whether its first call was a provable cold start; on Flex the platform usually hands a new app a worker it started earlier, so most first calls are not. The cold first call is not paired with Lambda's unless ten runs on each network prove a cold start. From the probe release of November 14, 2026 (10:51 PM Pacific time) until the morning of November 15, the create and the update instead waited for the function to answer for 30 seconds without a break; in production Flex mixed 404s, the old code and stalls for 100 seconds and more after a deployment, so that wait failed about a third of creates and most updates, and it was withdrawn. Python, Java, .NET and PowerShell are offered on Flex and not tested; Ruby is not offered.
Queue Storage (azure.queue.centralus, beside SQS): each round creates a queue, sends one message, receives it, makes it visible again with new text, deletes it, then reads, updates (metadata: Queue Storage has no queue-level delay) and deletes the queue. Queue Storage has no long poll, so no receive can be waiting when the message is sent: the receiver is a loop of back-to-back receives on one connection, started before the send, and receive-message runs from the send's request to the answer of the first receive that carried the message. Its resolution is one receive's round trip, a different method from SQS's long poll.
Service Bus (azure.servicebus.centralus, beside SNS and Pub/Sub): one Standard namespace per test network (Basic has no topics). Each round creates a topic and a subscription, publishes one message and receives it, then unsubscribes and reads, updates (the default message TTL) and deletes the topic. The receive is a peek-lock long poll started before the publish; receive-message runs from the publish's request to the first response header of the receive that carried it, on the same boundary as SNS and Pub/Sub (readiness: the client wrote the receive's request, not the server's acceptance). Event Grid and Event Hubs are not tested.
Azure DNS (azure.dns, global, beside Route 53 and Cloud DNS): the same eight steps. The zone and record changes end when every name server Azure assigned the zone answers them, queried every 250 ms; the zone update changes its tags, since an Azure zone has no description.
Foundry inference (azure.foundry.global, beside Bedrock and Agent Platform): each round deploys the model to the standing Foundry account (Global Standard, capacity 10), asks the same four prompts as Bedrock with a new request id each (at most 64 output tokens; Claude over Foundry's Anthropic Messages API, gpt-oss-120b over the OpenAI v1 chat API, with the same reasoning switches as Bedrock), then reads, raises the capacity and deletes the deployment. Global Standard serves a request from anywhere, so the ids name global and each result records the deployment type and the account's region (Central US), never a serving region. A prompt that stalls is asked once more with new bytes, as on Google Cloud. gpt-oss-120b runs from the first release; Claude Haiku and Sonnet start once Azure grants their quota.
Since November 13, 2026, 9:49 PM Pacific time (a zone-file update), the azure.cdn network tests (https, tcping4 and tcping6 to azure.cdn) measure js.monitor.azure.com, Microsoft's own Front Door endpoint for its Application Insights SDK, fetching a 1.8 KB cached JSON object over https, as gcp.cdn measures virustotal.com. Until then they measured cdn.azure-ping.com, a Front Door Standard profile Cloud Looking Glass ran itself, which is retired. The ids keep their names, so their history shows a step at the change.
Since @VENDOR-DATE@, CLG also stores each cloud provider's own published latency for the things CLG measures, as separate series beside CLG's own. Each of these status ids ends its operation with -vendor, for example aws.ec2.us-east-1.use1-az1--dp--rtt-vendor--aws.ec2.us-east-1.use1-az2 beside the tcping series of the same zone pair, and aws.dynamodb.us-east-1--dp--put-item-vendor beside put-item. One job per cloud and test network reads them every 10-minute round on CLG's own probes, through each provider's read-only monitoring API.
CLG's own measurement stays the method. A CLG test run measures the best case a customer can get from a service and proves that the service works, which no provider aggregate can. A provider-published series is never counted as availability and never raises an event. A round for which the provider published nothing is stored with no value at all, never as a failure.
Each job reads the provider's points for the round before last, the window from 20 to 10 minutes before its own round, because by then both providers have published them (AWS within about 5 minutes, Google within about 8). A provider-published series therefore runs two rounds behind CLG's own, and the charts draw it moved back by that much on the 10- and 20-minute views. Each stored value is the median of the provider's points in its window (two 5-minute points from AWS's network figures, up to ten 1-minute points elsewhere), in milliseconds.
The zone and region round trips come from AWS Infrastructure Performance (aggregate network latency, p50, every 5 minutes) between each pair of the five us-east-1 Availability Zones and from us-east-1 to 24 Regions, and from Google Cloud's zone_pair_median_rtt (the median TCP round trip of all Google Cloud customers' VM traffic between two zones, every minute) for us-central1's four zones and from us-central1 to 42 other regions (us-east4's three zones until the move of GCP's tests to us-central1). AWS publishes no figure for its opt-in Regions or Local Zones. AWS's figure times the network between its hosts, without a VM's own network stack: on November 8, 2026 its same-zone p50 was 0.037 to 0.091 ms across the five zones, against a wire round trip of about 0.19 ms between two VMs in use1-az1. Google's same-zone figure in us-east4 (0.164 to 0.535 ms) was within about 0.06 to 0.08 ms of the wire round trip between two VMs in one project in us-east4-a. CLG has no VM-to-VM test between Google Cloud regions, so the nearest CLG series to Google's region figures is the TCP connect to each region's Cloud Storage endpoint, a different path.
The per-resource figures are the server-side latency each provider publishes for CLG's own test resources: Amazon EBS read and write latency for General Purpose SSD gp2 and gp3 (per minute, as total read or write time over operations), each from a 1 GiB volume made with one test probe per account, which does about a second of small reads and writes every minute: CloudWatch publishes a volume's figures only for a minute with I/O, and published nothing at all for about half of CLG's own test volumes, which are attached for about 30 seconds, so the Provisioned IOPS (io1, io2) and HDD (st1, sc1) types have no provider series, Amazon DynamoDB request latency per operation (for the test's own table), AWS Lambda duration (p50) per runtime and the cold start's init duration from the invocation's own log (except .NET: since November 10, 2026 its cold invoke no longer asks for the log, since asking added 38 to 44 ms, 5.5 to 6.5%, to CLG's own .NET cold invoke over a day, while the other runtimes showed no cost), Amazon Bedrock invocation latency per model, and the Amazon S3 first-byte and total request latency of the bucket CLG's HTTP tests read (request metrics, over every client's requests, so the total includes each client's transfer). On Google Cloud they are Firestore request latency per method, Cloud Run functions execution time, Agent Platform model invocation latency per model, Pub/Sub publish latency, and the average I/O latency per disk type (no read and write split), each type read from one long-lived kind of disk only: Persistent Disk Balanced from the test probes' own boot disks, Persistent Disk SSD and Standard from a 10 GiB volume of each on one test probe per project, which does about a second of small reads and writes every minute (Google publishes a disk's latency only for a minute with I/O), and Hyperdisk Balanced from the boot disk of the Linux instance test's VM, which publishes only while a VM is running. Since November 9, 2026 (a hot patch), a round with no published point for Hyperdisk Balanced or for Firestore's document writes (CreateDocument) repeats Google's newest point from up to an hour before its window, and its record names the minute that point is from; past the hour the round has no value. Google's Firestore figures are per-method medians over all of the project's requests, so its update and delete figures also include the Firestore test's untimed readiness calls (a write and a delete of a separate document), which CLG's own timed steps leave out. CLG's own test disks are not used: attached for 30 to 40 seconds, about one in seven publishes a point, and that point reads 15 to 30 times the disk's fio latency. These are measured inside the provider's service, so they leave out the network and client time that CLG's own measurements include. The providers publish no latency figure for Amazon EFS, Amazon SQS, Amazon SNS, Cloud Storage, the public zones of Amazon Route 53 and Cloud DNS, Amazon S3 Tables, Amazon CloudFront and Cloud CDN, control plane operations or VM boot.
What separates CLG's measurements from the provider's own figures was measured on November 9, 2026 for the Google Cloud Firestore and Pub/Sub tests, with the same calls made by hand from a us-central1 probe in each test project and Google's figures read for those calls alone. The difference is Google's front end and the network, not the probe: each call already runs on a warm HTTP/2 connection, and its first response byte arrives within 0.2 milliseconds of its end. On Firestore's regional endpoint a document call took 3.8 to 5.5 milliseconds more than Google's figure (median per call type and project), and on Pub/Sub's regional endpoint a publish took 6.5 to 7.8 milliseconds more (15.7 to 17.1 on the locational endpoint the test uses; see Warm Connections for API Calls), for comparison with 1.0 to 1.4 milliseconds over AWS's figure for DynamoDB. Google's own figure for Firestore varies by database: two databases created minutes apart in one project read medians up to 10 milliseconds apart for the same call. The first few publishes to a Pub/Sub topic after it has been idle take 40 to 80 milliseconds and later ones about 11, inside Google's figure too, and each CLG run publishes once to a topic it has just created. Google's Firestore figures for updates and deletes also count the write and delete that the test's create step makes, untimed, to show the new database takes writes.
AWS's published write latency for the gp2 and gp3 volumes read 0.85 milliseconds per write, about twice CLG's own fio write on its test volumes (0.45 milliseconds). On November 9, 2026, EBS's own counters on the probe gave the same figure as fio for the same writes, and the EBS test's own workload on the same gp2 volume read 0.34 milliseconds. The difference is in the volume's blocks: CLG's test writes its whole region seconds before it measures, while the timer writes at random into blocks not written recently, each block about once every five and a half hours. Once each volume's region was written in full by hand, AWS's figure fell, for gp2 from 12:20 PM Pacific time to about 0.35 milliseconds for 34 minutes, and for gp3 from 12:50 PM Pacific time to about 0.45 milliseconds for 61 minutes, and then returned to 0.85. AWS's 0.85 milliseconds is therefore the steady state for writes to blocks not written within about the last hour, and CLG's 0.45 milliseconds the state of blocks written seconds before; each is true of its own blocks, and neither series is adjusted. The gp2 series has two odd minutes at 12:18 and 12:19 PM Pacific time, which hold the hand-run writes themselves, and gp3 one at 12:49 PM.
Cloud Looking Glass stores its cloud service monitoring data in a PostgreSQL database: raw test results, the rollup tables built from them, and the documented outages.
Operating Cloud Looking Glass involves significant real costs:
Note: RIPE Atlas measurements are obtained through credits earned by hosting a RIPE Atlas Anchor Probe.
Sponsorship funds are used exclusively to cover these operational costs, enabling us to:
Research Goals:
The database contains tables storing raw measurement data, test metadata, and event documentation.
┌─────────────────────────────────────────────────────────────────────────┐
│ CLOUD LOOKING GLASS SCHEMA │
└─────────────────────────────────────────────────────────────────────────┘
PRIMARY TABLES
┌──────────────────────┐ ┌──────────────────────┐ ┌──────────────────────┐
│ tests │ │ test_commands │ │ test_targets │
├──────────────────────┤ ├──────────────────────┤ ├──────────────────────┤
│ test_id (PK) │──┤ test_id (FK) │ │ test_id (FK) │◄┐
│ initiator │ │ sequence │ │ type │ │
│ name │ │ command │ │ cloud │ │
│ params │ │ name │ │ cloud_region │ │
│ status │ │ status │ │ cloud_region_zone │ │
│ timestamp │ │ status_ids[] │ │ cloud_service │ │
│ util_cpu │ │ measurement_mean │ │ cloud_service_type │ │
│ util_ram │ │ measurement_median │ │ cloud_sku │ │
└──────────────────────┘ │ measurements[] │ │ geo_country │ │
│ │ measurements_cli[] │ │ geo_country_state │ │
│ │ measurements_wall[] │ │ geo_regions[] │ │
│ │ metric │ │ hostname │ │
│ │ unit │ │ ipv4 │ │
│ │ stdout │ │ ipv6 │ │
│ │ stderr │ └──────────────────────┘ │
│ │ timestamp │ │
│ └──────────────────────┘ │
│ │ │
│ │ │
│ │ │
┌──────────────────────┐ │ │
│ test_outages │ │ │
├──────────────────────┤ │ │
│ outage_id (PK) │ │ │
│ operation │ │ │
│ test_ids[] │◄──────────┴────────────────────────────────────────┘
│ status_ids[] │◄──────────┘
│ partial │
│ notes │
│ tlds[] │
│ vendor_private_notes │
│ vendor_status_page_ │
│ notes │
└──────────────────────┘
ROLLUP TABLES
┌──────────────────────────┐ ┌─────────────────────────────────────┐
│ test_status (real-time) │ │ test_status_* (rollup tables) │
├──────────────────────────┤ ├─────────────────────────────────────┤
│ status_id (PK) ◄─────────┼─────┤ status_id (PK) │
│ tld (PK) │ │ interval_start (PK) │
│ expires │ │ interval_stop │
│ measurements[] │ │ events_com │
│ measurements_current[] │ │ events_net │
│ status │ │ events_merged │
│ stdev[] │ │ events_merged │
└──────────────────────────┘ │ measurements_min │
│ measurements_max │
│ measurements_mean │
│ measurements_p10 │
│ measurements_p25 │
│ measurements_p50 │
│ measurements_p75 │
│ measurements_p90 │
│ outage_ids[] │
│ stdev_min │
│ stdev_max │
│ stdev_mean │
│ stdev_p10 │
│ stdev_p25 │
│ stdev_p50 │
│ stdev_p75 │
│ stdev_p90 │
│ tests │
└─────────────────────────────────────┘
Rollup Table Intervals:
• test_status_1w - 10 minute intervals, 1 week retention
• test_status_1m - 20 minute intervals, 1 month retention
• test_status_3m - 30 minute intervals, 3 month retention
• test_status_6m - 1 hour intervals, 6 month retention
• test_status_1y - 2 hour intervals, 1 year retention
• test_status_2y - 4 hour intervals, 2 year retention
• test_status_3y - 6 hour intervals, 3 year retention
• test_status_4y - 8 hour intervals, 4 year retention
• test_status_5y - 12 hour intervals, 5 year retention
• test_status_daily - 24 hour intervals, unlimited retention
Key Relationships:
→ tests.test_id ← test_commands.test_id (1:many)
→ tests.test_id ← test_targets.test_id (1:many)
→ tests.test_id ← test_outages.test_ids[] (many:many)
→ test_commands.status_ids[] → test_outages.status_ids[] (many:many)
→ test_commands.status_ids[] → test_status_* rollup tables (aggregated)
The following sections describe each table in the Cloud Looking Glass database.
Purpose: Core table storing metadata about each test execution.
Key Fields:
test_id (STRING): Unique identifier for each test (UUID format, e.g., 'd62801d3-5674-4359-ac97-5e84d60e100d')initiator (STRING): Entity that triggered the test - 'cron' (universal tests) or 'webqueue' (distributed tests)name (STRING): Test name - either CRUD operations (e.g., 'crud-instance-linux', 'crud-bucket') or network tests (e.g., 'tcping4', 'https', 'dns')params (JSON): Test parameters and configuration (e.g., {"source":"central-america"}). From 6:40 PM Pacific time, November 10, 2026, deferred counts how many times the probe put the test back on its queue for 15 seconds before it ran: because its CPU was 90% or more busy, or another CPU-heavy control-plane test was running (at most 3 times), or, from 9:50 AM Pacific time, November 11, 2026, because other RIPE Atlas or Globalping tests already held every worker but one (until minute 6). Every test still runs once in its own 10-minute round, and from minute 6 of the round it runs at oncestatus (STRING): Overall test result ('success', 'failed', 'error', 'mixed')timestamp (TIMESTAMP): When the test was executedutil_cpu (INT64): CPU busy percentage during the test attempt (0-100): the share of all the probe's vCPUs that was busy, steal included and I/O wait not, from /proc/stat. Before 6:47 PM Pacific time, November 9, 2026 it was the 1-minute load average per vCPU, capped at 100. A run that reads 100 is kept as measured: after the probe CPU changes of November 10, 2026, about 0.5% of the Google Cloud probes' runs read 100, almost all of them tcping runs, whose handshake time comes from the kernel and moved by at most 0.1 ms at 100util_ram (INT64): RAM utilization percentage when the result was built (0-100): (MemTotal - MemAvailable) / MemTotal from /proc/meminfo, on every probe. Before 6:00 PM Pacific time, November 10, 2026 it was the free command's "used" share: the same value on the GCE probes, but lower on the AWS probes, whose older free left buffers and cache outClustering: By name for efficient querying by test type
Check Constraints: Status must be one of: 'success', 'failed', 'error', 'mixed'
Purpose: Detailed record of each command executed within a test, including measurements and output.
Key Fields:
test_id (STRING): Foreign key linking to tests tablesequence (INT64): Order of command execution within the test (1-based, default: 1)command (STRING): Actual CLI command executed (e.g., 'tcping -r 4 43.196.0.253 80')name (STRING): Command name (e.g., 'create-instance-linux', 'attach-volume-st1')status (STRING): Command execution result ('success', 'failed', 'error', 'mixed')status_ids (ARRAY<STRING>): Structured identifiers for the operations, correlates to test_status tables (e.g., ['aws.ec2.us-east-1--cp--create-instance-linux'])Measurement Fields - Critical Distinctions:
The three measurement arrays capture different timing perspectives, enabling both accurate cross-provider comparisons and real-world performance analysis:
measurements (ARRAY<FLOAT64>):
measurements_cli (ARRAY<FLOAT64>):
measurements_wall (ARRAY<FLOAT64>):
Statistical Fields:
measurement_mean (FLOAT64): Average of the measurements array (e.g., 15920 ms for EC2 instance creation)measurement_median (FLOAT64): Median of the measurements array (50th percentile)measurement_stdev (FLOAT64): Standard deviation indicating consistency/variabilityMetadata Fields:
metric (STRING): What was measured ('latency', 'rtt', 'throughput', 'iops')unit (STRING): Measurement unit ('ms', 'MB/s', 's', 'IOPS')stdout (STRING): Command standard outputstderr (STRING): Command error outputtimestamp (TIMESTAMP): Command execution timeImportant Notes on Measurements:
measurements and measurements_wall can be 10x or moremeasurements array is the primary metric for fair cross-provider comparisonsmeasurements_wall when analyzing user-perceived performancePartitioning: By DATE(timestamp) for efficient time-based queries
Primary Key: Composite of (test_id, sequence, timestamp)
Purpose: Source and destination information for tests, including cloud provider and geographic details.
Key Fields:
test_id (STRING): Foreign key linking to tests tabletype (STRING): Target type ('source', 'dest', 'target')cloud (STRING): Provider name - supports 26+ providers including: aws, gcp, azure, alibaba, tencent, cloudflare, akamai, fastly, etc.cloud_region (STRING): Region identifier (e.g., 'us-east-1', 'cn-north-1', 'ap-southeast-1')cloud_region_zone (STRING): Availability zone (e.g., 'use1-az1', 'use1-az2')cloud_service (STRING): Service name (e.g., 'ec2', 's3', 'cloudfront')cloud_service_type (STRING): Service variant (e.g., 'compute', 'storage')cloud_sku (STRING): SKU/instance type (e.g., 't3.micro', 'gp3')geo_country (CHAR(2)): ISO 3166-1 alpha-2 country codegeo_country_state (CHAR(2)): State/province codegeo_regions (ARRAY<STRING>): Geographic regions (e.g., ['eu'], ['mea'], ['apac'])hostname (STRING): Test agent hostname (e.g., 'use1-az2.us-east-1.aws-ping.com')ipv4 (STRING): IPv4 addressipv6 (STRING): IPv6 addressClustering: By cloud for efficient provider-specific queries
Primary Key: Composite of (test_id, type)
Purpose: Manually verified and documented service outages with detailed analysis.
Key Fields:
outage_id (STRING): Unique identifier following patterns:operation (STRING): Specific operation that failed (e.g., 'attach-volume-st1', 'converse-fact-claude-haiku')test_ids (ARRAY<STRING>): Array of affected test IDspartial (BOOLEAN): Whether outage affected all accounts (FALSE) or subset (TRUE) - most outages are partialnotes (STRING): Detailed description of the failure with specific error messagesstatus_ids (ARRAY<STRING>): Structured identifiers for affected services (see Status ID Format section)tlds (ARRAY<STRING>): Top-level domains affected ('com', 'net') corresponding to test accountsvendor_private_notes (STRING): Internal vendor communications (usually NULL)vendor_status_page_notes (STRING): Public vendor status page entries (usually NULL)Primary Key: outage_id
Purpose: Time-based aggregation tables providing historical analysis at various granularities.
Note: These aggregation tables are pre-computed in PostgreSQL for efficient time-series analysis.
Available Tables:
test_status - Real-time ingest table (24-hour window, 10-minute intervals)test_status_1w - 10-minute aggregates with 1-week retentiontest_status_1m - 20-minute aggregates with 1-month retentiontest_status_3m - 30-minute aggregates with 3-month retentiontest_status_6m - 1-hour aggregates with 6-month retentiontest_status_1y - 2-hour aggregates with 1-year retentiontest_status_2y - 4-hour aggregates with 2-year retentiontest_status_3y - 6-hour aggregates with 3-year retentiontest_status_4y - 8-hour aggregates with 4-year retentiontest_status_5y - 12-hour aggregates with 5-year retentiontest_status_daily - 24-hour aggregates with unlimited retentionKey Fields (Common Across All Rollup Tables):
status_id (STRING): Test identifier following the Status ID Format (see Important Notes section)interval_start (TIMESTAMP): Beginning of the time windowinterval_stop (TIMESTAMP): End of the time windowevents_com, events_net, events_merged (INT64): Event counts per TLD and merged viewmeasurements_min, measurements_max, measurements_mean (FLOAT64): Statistical aggregatesmeasurements_p10, measurements_p25, measurements_p50, measurements_p75, measurements_p90 (FLOAT64): Percentile valuesoutage_ids (ARRAY<STRING>): Associated outage identifiers for this time windowstdev_min, stdev_max, stdev_mean (FLOAT64): Standard deviation statisticsstdev_p10, stdev_p25, stdev_p50, stdev_p75, stdev_p90 (FLOAT64): Standard deviation percentilestests (INT64): Total test count in the intervalReal-time Status Table (test_status):
tld (STRING): Top-level domain ('com', 'net', 'merged')expires (TIMESTAMP): When current measurement window expiresmeasurements (ARRAY<FLOAT64>): Historical measurements (144 values = 24 hours)measurements_current (ARRAY<FLOAT64>): Current window measurementsstatus (STRING): Current status indicatorstdev (ARRAY<FLOAT64>): Rolling standard deviation valuesUsage Notes:
Cloud services in the CLG testing framework are classified into two fundamental types based on their operational independence and testing requirements. This classification is essential for understanding the test design and the relationships between different services.
Primary services are standalone, fully functional cloud resources that can operate independently without requiring attachment to other services. These services have both control plane and data plane operations that can be tested in isolation.
Characteristics of Primary Services:
Examples of Primary Services:
Supporting services (also called secondary services) are cloud resources that provide essential capabilities but require attachment to or integration with primary services to demonstrate their functional value. While these services have their own control plane operations, their data plane functionality is only meaningful when connected to a primary service.
Characteristics of Supporting Services:
Examples of Supporting Services:
crud-volume-{type} includes attach/detach to EC2 instancesTesting Implications:
The distinction between primary and supporting services has important implications for test design:
aws.ebs.us-east-1--cp--attach-volume-gp3Query Example - Identifying Service Dependencies:
-- Find tests that involve both primary and supporting services
WITH service_dependencies AS (
SELECT
t.name as test_name,
tc.name as command_name,
CASE
WHEN tc.name LIKE '%attach%' OR tc.name LIKE '%detach%' THEN 'Supporting Service Operation'
WHEN tc.name LIKE '%mount%' OR tc.name LIKE '%unmount%' THEN 'Supporting Service Operation'
ELSE 'Standard Operation'
END as operation_type,
tc.status,
tc.measurement_mean
FROM clg.tests t
JOIN clg.test_commands tc ON t.test_id = tc.test_id
WHERE t.name LIKE 'crud-volume-%'
OR t.name LIKE 'crud-filesystem-%'
)
SELECT
test_name,
operation_type,
COUNT(*) as operation_count,
AVG(measurement_mean) as avg_duration_ms,
COUNTIF(status = 'success') / COUNT(*) as success_rate
FROM service_dependencies
GROUP BY test_name, operation_type
ORDER BY test_name, operation_type;
The CLG monitoring system organizes tests into three distinct categories based on the type of operations being measured. The test category is embedded directly in the status_id using the separator pattern: --cp-- for Control Plane and --dp-- for Data Plane (including Networking). This convention enables efficient filtering and aggregation of test results by category.
Purpose: Validate cloud provider API operations for resource lifecycle management (Create, Read, Update, Delete).
crud-{service} or crud-{service}-{variant}{cloud}.{service}.{region}--cp--{operation}aws.ec2.us-east-1--cp--create-instance-linuxExamples with Status IDs:
crud-instance-linuxaws.ec2.us-east-1--cp--create-instance-linuxcrud-bucketaws.s3.us-east-1--cp--create-bucket, aws.s3.us-east-1--cp--delete-bucketcrud-volume-gp3aws.ebs.us-east-1--cp--create-volume-gp3, aws.ebs.us-east-1--cp--attach-volume-gp3crud-function-pythonaws.lambda.us-east-1--cp--update-function-pythoncrud-distroaws.cloudfront--cp--create-distrocrud-function-nodejsgcp.functions.us-central1--cp--create-function-nodejsNote: The --cp-- separator clearly identifies these as Control Plane operations, distinguishing them from Data Plane operations.
Purpose: Measure performance of operations on existing cloud resources (not network connectivity).
{cloud}.{service}.{region}--dp--{operation}aws.lambda.us-east-1--dp--invoke-function-pythonExamples with Status IDs:
aws.bedrock.global--dp--converse-fact-claude-haikuaws.lambda.us-east-1--dp--invoke-function-pythonaws.dynamodb.us-east-1--dp--get-itemaws.s3.us-east-1--dp--put-object-standardaws.ebs.us-east-1--dp--seq-write-gp3aws.sqs.us-east-1--dp--send-messagegcp.aiplatform.global--dp--converse-fact-gemini-flashNote: Data Plane operations use --dp-- but follow the pattern {cloud}.{service}.{region}--dp--{operation}, without source/destination components.
Purpose: Measure network connectivity, latency, and performance between endpoints. While technically part of the data plane, networking tests form such a large category (1,512+ status IDs) that they are tracked separately.
{source}--dp--{test-type}--{destination}aws.ec2.us-east-1--dp--tcping4--aws.s3.us-east-1Test Types:
tcping4, tcping6: TCP connectivity tests (IPv4/IPv6)ping4, ping6: ICMP ping testsdns, adns, gdns: DNS resolution tests (standard/RIPE Atlas/Globalping)aping4, aping6, gping4, gping6: External ping tests via RIPE Atlas / Globalpinghttp, https: HTTP/HTTPS endpoint availabilityhttpb-100mb, httpsb-100mb: Two-byte random reads of a 100 MB object, for read latency on a large object rather than throughputExamples with Status IDs:
aws.ec2.us-east-1--dp--tcping4--aws.s3.us-east-1aws.ec2.us-east-1--dp--dns--aws.route53eu--dp--aping4--aws.cloudfront72 status IDs
aws.ec2.us-east-1.use1-az1--dp--tcping4--aws.ec2.us-east-1.use1-az277 status IDs
aws.ec2.us-east-1--dp--tcping4--aws.s3.us-east-1183 status IDs
aws.ec2.us-east-1--dp--tcping4--aws.ec2.eu-west-152 status IDs
aws.ec2.us-east-1--dp--https--aws.cloudfront724 status IDs
aws.ec2.us-east-1--dp--tcping4--gcp.compute.us-central1471 status IDs
north-america--dp--gping4--aws.ec2.us-east-1Note: The {source}--dp--{test-type}--{destination} pattern in networking status IDs enables precise tracking of network paths and performance metrics across different scopes.
Availability measures whether a service is operational and accessible. In the CLG dataset, availability is determined by:
test_outages table indicate availability issuesevents_com, events_net columns show per-account impactevents_merged column indicates cross-account availability issues (2-3 accounts affected simultaneously)-- Service availability over the last 24 hours
SELECT
status_id,
COUNT(*) as total_tests,
SUM(CASE WHEN events_merged = 0 THEN 1 ELSE 0 END) as successful_tests,
ROUND(100.0 * SUM(CASE WHEN events_merged = 0 THEN 1 ELSE 0 END) / COUNT(*), 2) as availability_percent
FROM clg.test_status_1w
WHERE interval_start >= TIMESTAMP_SUB(CURRENT_TIMESTAMP(), INTERVAL 24 HOUR)
AND status_id LIKE 'aws.ec2%--cp--%'
GROUP BY status_id
ORDER BY availability_percent ASC;
Performance measures how quickly and efficiently a service responds when it is available. The CLG dataset captures multiple performance dimensions:
The CLG measurement approach aims to capture timing as close to the actual API request/response wire time as possible. This methodology is critical for enabling fair comparability across cloud providers, as different provider CLIs have vastly different non-operation related overheads (e.g., AWS CLI is Python-based while other providers use compiled Go binaries that load faster).
measurements[]: The primary measurement array captures the time delta between initial API request and response for the specific operation. This reflects the actual API performance at the wire level, excluding IAM authentication and other pre-request operations. This is the most comparable metric across providers as it isolates the actual service performance from CLI implementation differences.measurements_cli[]: Since November 8, 2026, the call's cold-equivalent: what it would have read on a fresh connection (its DNS, TCP and TLS setup plus the call). Until then, an AWS test's held the API operation time plus IAM-related pre-requests and authentication overhead extracted from the AWS CLI's debug output, which still excluded the CLI's loading time.measurements_wall[]: The total wall clock time of the step's process (since November 8, 2026 one curl process: its warm-up request, the call and the response; until then an AWS test's AWS CLI command), which is the longest measurement as it includes:
Since November 8, 2026 the tests of both clouds call the services' APIs with curl, which times each call itself on a connection an untimed warm-up request opened: the clock covers the request and the whole response. Until then, AWS tests ran the AWS CLI with --debug, whose log timed each call from before it connected, so its window included the DNS lookup, the TCP connect and the TLS handshake, as curl's did on Google Cloud: both covered a fresh connection, the request and the whole response. CLG's cross-cloud measurement contract (src/php/clg/harness/README.md) defines what each kind of step measures on every provider: when a step is done, how a retried call is timed, and what a wait counts.
In test_commands table:
measurements[]: Array of raw API timing measurements in milliseconds (closest to actual API performance)measurements_wall[]: Wall clock time measurements (total elapsed time including all overhead)measurements_cli[]: The call's cold-equivalent since November 8, 2026 (its connection setup plus the call); before, an AWS test's CLI-specific timing extracted from debug output (includes IAM but excludes CLI loading)measurement_mean: Average of all measurementsmeasurement_median: Median value (50th percentile)measurement_stdev: Standard deviation indicating consistencyIn rollup tables (test_status_*):
measurements_min: Minimum observed value in the time windowmeasurements_max: Maximum observed value in the time windowmeasurements_mean: Average across all measurementsmeasurements_p10: 10th percentile (fastest 10%)measurements_p25: 25th percentile (first quartile)measurements_p50: 50th percentile (median)measurements_p75: 75th percentile (third quartile)measurements_p90: 90th percentile (slowest 10%)-- Analyze EC2 instance creation performance trends
SELECT
DATE(interval_start) as date,
status_id,
AVG(measurements_mean) as avg_latency_ms,
AVG(measurements_p90) as p90_latency_ms,
MAX(measurements_max) as max_latency_ms
FROM clg.test_status_daily
WHERE status_id = 'aws.ec2.us-east-1--cp--create-instance-linux'
AND interval_start >= DATE_SUB(CURRENT_DATE(), INTERVAL 30 DAY)
GROUP BY date, status_id
ORDER BY date DESC;
-- Identify performance degradation by comparing current vs historical
SELECT
tc.name as operation,
AVG(tc.measurement_mean) as current_avg_ms,
hist.historical_avg_ms,
ROUND(100.0 * (AVG(tc.measurement_mean) - hist.historical_avg_ms) / hist.historical_avg_ms, 1) as percent_change
FROM clg.test_commands tc
JOIN (
SELECT
name,
AVG(measurement_mean) as historical_avg_ms
FROM clg.test_commands
WHERE timestamp BETWEEN TIMESTAMP_SUB(CURRENT_TIMESTAMP(), INTERVAL 30 DAY)
AND TIMESTAMP_SUB(CURRENT_TIMESTAMP(), INTERVAL 7 DAY)
GROUP BY name
) hist ON tc.name = hist.name
WHERE tc.timestamp >= TIMESTAMP_SUB(CURRENT_TIMESTAMP(), INTERVAL 24 HOUR)
AND tc.measurement_mean IS NOT NULL
GROUP BY tc.name, hist.historical_avg_ms
HAVING percent_change > 20
ORDER BY percent_change DESC;
Cloud service incidents can be categorized into two primary types based on their scope and impact. The CLG schema provides multiple mechanisms to differentiate between these event types through the strategic use of dual-redundant test accounts and cross-account correlation.
Isolated events are service disruptions that do not impact all test accounts simultaneously. When a failure occurs in only one or two of our three redundant test accounts while others continue operating normally, this indicates an isolated event rather than a widespread service issue. These events typically indicate:
Note: Account-specific issues like IAM misconfigurations, quota limits, rate limiting, or permission problems are removed from our dataset as they don't represent actual service availability issues.
The CLG dataset identifies isolated events through several key indicators:
-- Find isolated events affecting single accounts
SELECT
status_id,
interval_start,
events_com,
events_net,
events_merged,
CASE
WHEN (events_com > 0 AND events_net = 0 THEN 'Isolated to .com'
WHEN (events_net > 0 AND events_com = 0 THEN 'Isolated to .net'
ELSE 'Multiple accounts affected'
END as isolation_pattern
FROM clg.test_status_1w
WHERE interval_start >= TIMESTAMP_SUB(CURRENT_TIMESTAMP(), INTERVAL 24 HOUR)
AND events_merged = 0 -- No merged events indicates no cross-account impact
AND (events_com + events_net) > 0 -- At least one failure
ORDER BY interval_start DESC;
test_outages.partial = TRUE flag indicates limited impact
-- Analyze partial outages (isolated events)
SELECT
outage_id,
operation,
ARRAY_LENGTH(test_ids) as affected_tests,
ARRAY_LENGTH(tlds) as affected_accounts,
notes
FROM clg.test_outages
WHERE partial = TRUE
AND ARRAY_LENGTH(tlds) = 1 -- Single account affected
ORDER BY outage_id DESC
LIMIT 20;
events_merged Values: Indicates failures are not synchronized across accountsLarge Service Events are incidents observed to impact multiple unrelated customer accounts for the same provider at the same time. LSEs represent significant availability issues that affect the service broadly, rather than isolated customer-specific problems. LSEs typically indicate:
The CLG dataset provides several mechanisms to identify and differentiate LSEs from isolated events:
partial Column in test_outages:
partial = FALSE: Indicates all two test accounts (.com, .net, .org) were affected - strong LSE indicatorpartial = TRUE: Indicates only 1-2 accounts affected - may be isolated or limited in scopeevents_com, events_net: Count of failed tests per TLD accountevents_merged: Count of tests where 2-3 accounts failed simultaneouslyevents_merged values indicate LSEs affecting multiple accounts-- Identify potential LSEs by finding simultaneous failures across accounts
SELECT
status_id,
interval_start,
events_com,
events_net,
events_merged,
CASE
WHEN events_merged > 0 AND events_merged >= 0.5 * tests THEN 'Likely LSE'
WHEN events_merged > 0 THEN 'Possible LSE'
ELSE 'Isolated Event'
END as event_classification,
outage_ids
FROM clg.test_status_1w
WHERE interval_start >= TIMESTAMP_SUB(CURRENT_TIMESTAMP(), INTERVAL 24 HOUR)
AND (events_com > 0 OR events_net > 0 )
AND status_id LIKE 'aws%'
ORDER BY events_merged DESC, interval_start DESC
LIMIT 100;
-- Analyze documented outages to identify LSEs
SELECT
outage_id,
operation,
partial,
ARRAY_LENGTH(test_ids) as affected_tests,
ARRAY_LENGTH(tlds) as affected_tlds,
notes,
CASE
WHEN partial = FALSE THEN 'Confirmed LSE'
WHEN ARRAY_LENGTH(tlds) >= 2 THEN 'Probable LSE'
ELSE 'Isolated/Limited Impact'
END as lse_classification
FROM clg.test_outages
WHERE ARRAY_LENGTH(test_ids) > 0
ORDER BY outage_id DESC
LIMIT 50;
To assess the impact and scope of an LSE:
-- LSE analysis
WITH event_summary AS (
SELECT
DATE(interval_start) as event_date,
EXTRACT(HOUR FROM interval_start) as event_hour,
STRING_AGG(DISTINCT REGEXP_EXTRACT(status_id, r'\.(\\w+)\.'), ', ') as affected_services,
STRING_AGG(DISTINCT REGEXP_EXTRACT(status_id, r'\.([a-z]+-[a-z]+-\\d+)'), ', ') as affected_regions,
SUM(events_merged) as total_merged_events,
COUNT(DISTINCT status_id) as unique_status_ids,
MAX(measurements_max) as max_latency_observed
FROM clg.test_status_1w
WHERE interval_start >= TIMESTAMP_SUB(CURRENT_TIMESTAMP(), INTERVAL 7 DAY)
AND events_merged > 0
GROUP BY event_date, event_hour
HAVING total_merged_events > 10
)
SELECT
*,
CASE
WHEN unique_status_ids > 5 AND total_merged_events > 50 THEN 'Major LSE'
WHEN unique_status_ids > 2 AND total_merged_events > 20 THEN 'Moderate LSE'
ELSE 'Minor LSE'
END as severity
FROM event_summary
ORDER BY event_date DESC, total_merged_events DESC;
The following table summarizes how to distinguish between Isolated Events and Large Service Events using the CLG schema:
| Schema Element | Isolated Event | Large Service Event (LSE) |
|---|---|---|
test_outages.partial |
TRUE (1-2 accounts affected) |
FALSE (all 3 accounts affected) |
events_merged in rollups |
0 or very low | High values (>50% of tests) |
| TLD distribution | Single TLD shows failures | Multiple or all TLDs show failures |
test_outages.tlds[] array |
Length = 1 | Length ≥ 2 |
| Failure timing | Staggered across accounts | Simultaneous across accounts |
| Recovery pattern | Independent recovery | Synchronized recovery |
| Typical causes | Account limits, quotas, config | Service-wide outages |
-- Event classification query
WITH event_analysis AS (
SELECT
status_id,
interval_start,
events_com,
events_net,
events_merged,
tests,
ARRAY_LENGTH(outage_ids) as documented_outages,
-- Calculate affected account count
CAST(events_com > 0 AS INT64) +
CAST(events_net > 0 AS INT64) +
CAST(events_com > 0 AS INT64) + CAST(events_net > 0 AS INT64) as affected_accounts,
-- Calculate merge ratio
SAFE_DIVIDE(events_merged, GREATEST(events_com, events_net)) as merge_ratio
FROM clg.test_status_1w
WHERE interval_start >= TIMESTAMP_SUB(CURRENT_TIMESTAMP(), INTERVAL 24 HOUR)
AND (events_com > 0 OR events_net > 0 )
)
SELECT
*,
CASE
WHEN affected_accounts = 3 AND merge_ratio > 0.8 THEN 'Confirmed LSE'
WHEN affected_accounts >= 2 AND merge_ratio > 0.5 THEN 'Probable LSE'
WHEN affected_accounts >= 2 AND merge_ratio < 0.5 THEN 'Concurrent Isolated Events'
WHEN affected_accounts = 1 THEN 'Isolated Event'
ELSE 'Unknown'
END as event_classification
FROM event_analysis
ORDER BY interval_start DESC, events_merged DESC;
partial flag is authoritative: When documenting outages, the partial field in test_outages provides the definitive classification based on human analysis of the failure pattern.test_commands.status_ids array contains structured identifiers for each operation, enabling direct correlation with test_outages and rollup tables{cloud}.{service}.{region}--cp--{operation}{cloud}.{service}.{region}--dp--{operation}{source}--dp--{test-type}--{destination}global in place of the region (aws.bedrock.global--dp--converse-fact-claude-haiku, gcp.aiplatform.global--dp--converse-fact-gemini-flash); a model served in one region keeps it (aws.bedrock.us-east-1--...-gpt-oss-120b: Bedrock has no global profile for it, while Agent Platform serves it on its global endpoint, gcp.aiplatform.global--...-gpt-oss-120b, since card mpTFAfQU). When Bedrock's claude-haiku, claude-sonnet, gpt-luna and gpt-sol moved to its global inference profiles, their results measured since their first round (10:40 AM PST Nov 1 2026) moved to aws.bedrock.global in every table; everything before stays under the aws.bedrock.us-east-1 ids as a closed series - for claude-haiku, the earlier Claude 3 Haiku test since Feb 2025 and its outagesControl plane tests validate cloud provider API operations for resource lifecycle management.
aws.bedrock.global--cp--create-inference-claude-haiku
aws.bedrock.global--cp--create-inference-claude-sonnet
aws.bedrock.global--cp--create-inference-gpt-luna
aws.bedrock.us-east-1--cp--create-inference-gpt-oss-120b
aws.bedrock.global--cp--create-inference-gpt-sol
aws.bedrock.global--cp--delete-inference-claude-haiku
aws.bedrock.global--cp--delete-inference-claude-sonnet
aws.bedrock.global--cp--delete-inference-gpt-luna
aws.bedrock.us-east-1--cp--delete-inference-gpt-oss-120b
aws.bedrock.global--cp--delete-inference-gpt-sol
aws.bedrock.global--cp--read-inference-claude-haiku
aws.bedrock.global--cp--read-inference-claude-sonnet
aws.bedrock.global--cp--read-inference-gpt-luna
aws.bedrock.us-east-1--cp--read-inference-gpt-oss-120b
aws.bedrock.global--cp--read-inference-gpt-sol
aws.bedrock.global--cp--update-inference-claude-haiku
aws.bedrock.global--cp--update-inference-claude-sonnet
aws.bedrock.global--cp--update-inference-gpt-luna
aws.bedrock.us-east-1--cp--update-inference-gpt-oss-120b
aws.bedrock.global--cp--update-inference-gpt-sol
aws.cloudfront--cp--create-distro
aws.cloudfront--cp--delete-distro
aws.cloudfront--cp--read-distro
aws.cloudfront--cp--update-distro
aws.dynamodb.us-east-1--cp--create-kvtable
aws.dynamodb.us-east-1--cp--delete-kvtable
aws.dynamodb.us-east-1--cp--read-kvtable
aws.dynamodb.us-east-1--cp--update-kvtable
aws.ebs.us-east-1--cp--attach-volume-gp2
aws.ebs.us-east-1--cp--attach-volume-gp3
aws.ebs.us-east-1--cp--attach-volume-io1
aws.ebs.us-east-1--cp--attach-volume-io2
aws.ebs.us-east-1--cp--attach-volume-sc1
aws.ebs.us-east-1--cp--attach-volume-st1
aws.ebs.us-east-1--cp--create-volume-gp2
aws.ebs.us-east-1--cp--create-volume-gp3
aws.ebs.us-east-1--cp--create-volume-io1
aws.ebs.us-east-1--cp--create-volume-io2
aws.ebs.us-east-1--cp--create-volume-sc1
aws.ebs.us-east-1--cp--create-volume-st1
aws.ebs.us-east-1--cp--delete-volume-gp2
aws.ebs.us-east-1--cp--delete-volume-gp3
aws.ebs.us-east-1--cp--delete-volume-io1
aws.ebs.us-east-1--cp--delete-volume-io2
aws.ebs.us-east-1--cp--delete-volume-sc1
aws.ebs.us-east-1--cp--delete-volume-st1
aws.ebs.us-east-1--cp--detach-volume-gp2
aws.ebs.us-east-1--cp--detach-volume-gp3
aws.ebs.us-east-1--cp--detach-volume-io1
aws.ebs.us-east-1--cp--detach-volume-io2
aws.ebs.us-east-1--cp--detach-volume-sc1
aws.ebs.us-east-1--cp--detach-volume-st1
aws.ebs.us-east-1--cp--read-volume-gp2
aws.ebs.us-east-1--cp--read-volume-gp3
aws.ebs.us-east-1--cp--read-volume-io1
aws.ebs.us-east-1--cp--read-volume-io2
aws.ebs.us-east-1--cp--read-volume-sc1
aws.ebs.us-east-1--cp--read-volume-st1
aws.ebs.us-east-1--cp--update-volume-gp2
aws.ebs.us-east-1--cp--update-volume-gp3
aws.ebs.us-east-1--cp--update-volume-io1
aws.ebs.us-east-1--cp--update-volume-io2
aws.ebs.us-east-1--cp--update-volume-sc1
aws.ebs.us-east-1--cp--update-volume-st1
aws.ec2.us-east-1--cp--create-instance-linux
aws.ec2.us-east-1--cp--delete-instance-linux
aws.ec2.us-east-1--cp--read-instance-linux
aws.ec2.us-east-1--cp--update-instance-linux
aws.efs.us-east-1--cp--attach-efs-gp
aws.efs.us-east-1--cp--attach-efs-maxio
aws.efs.us-east-1--cp--create-efs-gp
aws.efs.us-east-1--cp--create-efs-maxio
aws.efs.us-east-1--cp--delete-efs-gp
aws.efs.us-east-1--cp--delete-efs-maxio
aws.efs.us-east-1--cp--detach-efs-gp
aws.efs.us-east-1--cp--detach-efs-maxio
aws.efs.us-east-1--cp--read-efs-gp
aws.efs.us-east-1--cp--read-efs-maxio
aws.efs.us-east-1--cp--update-efs-gp
aws.efs.us-east-1--cp--update-efs-maxio
aws.lambda.us-east-1--cp--create-function-dotnet
aws.lambda.us-east-1--cp--create-function-java
aws.lambda.us-east-1--cp--create-function-nodejs
aws.lambda.us-east-1--cp--create-function-python
aws.lambda.us-east-1--cp--create-function-ruby
aws.lambda.us-east-1--cp--delete-function-dotnet
aws.lambda.us-east-1--cp--delete-function-java
aws.lambda.us-east-1--cp--delete-function-nodejs
aws.lambda.us-east-1--cp--delete-function-python
aws.lambda.us-east-1--cp--delete-function-ruby
aws.lambda.us-east-1--cp--read-function-dotnet
aws.lambda.us-east-1--cp--read-function-java
aws.lambda.us-east-1--cp--read-function-nodejs
aws.lambda.us-east-1--cp--read-function-python
aws.lambda.us-east-1--cp--read-function-ruby
aws.lambda.us-east-1--cp--update-function-dotnet
aws.lambda.us-east-1--cp--update-function-java
aws.lambda.us-east-1--cp--update-function-nodejs
aws.lambda.us-east-1--cp--update-function-python
aws.lambda.us-east-1--cp--update-function-ruby
aws.route53--cp--create-record
aws.route53--cp--create-zone
aws.route53--cp--delete-record
aws.route53--cp--delete-zone
aws.route53--cp--read-record
aws.route53--cp--read-zone
aws.route53--cp--update-record
aws.route53--cp--update-zone
aws.s3.us-east-1--cp--create-bucket
aws.s3.us-east-1--cp--create-bucket-directory
aws.s3.us-east-1--cp--delete-bucket
aws.s3.us-east-1--cp--delete-bucket-directory
aws.s3.us-east-1--cp--read-bucket
aws.s3.us-east-1--cp--read-bucket-directory
aws.s3.us-east-1--cp--update-bucket
aws.s3tables.us-east-1--cp--create-s3table-bucket
aws.s3tables.us-east-1--cp--create-s3table-namespace
aws.s3tables.us-east-1--cp--create-s3table-table
aws.s3tables.us-east-1--cp--delete-s3table-bucket
aws.s3tables.us-east-1--cp--delete-s3table-namespace
aws.s3tables.us-east-1--cp--delete-s3table-table
aws.s3tables.us-east-1--cp--read-s3table
aws.s3tables.us-east-1--cp--rename-s3table-table
aws.sns.us-east-1--cp--create-topic
aws.sns.us-east-1--cp--delete-topic
aws.sns.us-east-1--cp--read-topic
aws.sns.us-east-1--cp--subscribe
aws.sns.us-east-1--cp--unsubscribe
aws.sns.us-east-1--cp--update-topic
aws.sqs.us-east-1--cp--create-queue
aws.sqs.us-east-1--cp--delete-queue
aws.sqs.us-east-1--cp--read-queue
aws.sqs.us-east-1--cp--update-queue
aws.vpc.us-east-1--cp--create-vpc
aws.vpc.us-east-1--cp--delete-vpc
aws.vpc.us-east-1--cp--read-vpc
aws.vpc.us-east-1--cp--update-vpc
gcp.aiplatform.global--cp--create-inference-gemini-flash
gcp.aiplatform.global--cp--delete-inference-gemini-flash
gcp.aiplatform.global--cp--read-inference-gemini-flash
gcp.aiplatform.global--cp--update-inference-gemini-flash
gcp.aiplatform.global--cp--create-inference-gpt-oss-120b
gcp.aiplatform.global--cp--delete-inference-gpt-oss-120b
gcp.aiplatform.global--cp--read-inference-gpt-oss-120b
gcp.aiplatform.global--cp--update-inference-gpt-oss-120b
gcp.dns--cp--create-record
gcp.dns--cp--create-zone
gcp.dns--cp--delete-record
gcp.dns--cp--delete-zone
gcp.dns--cp--read-record
gcp.dns--cp--read-zone
gcp.dns--cp--update-record
gcp.dns--cp--update-zone
gcp.firestore.us-central1--cp--create-database
gcp.firestore.us-central1--cp--delete-database
gcp.firestore.us-central1--cp--read-database
gcp.firestore.us-central1--cp--update-database
gcp.functions.us-central1--cp--create-function-nodejs
gcp.functions.us-central1--cp--delete-function-nodejs
gcp.functions.us-central1--cp--read-function-nodejs
gcp.functions.us-central1--cp--update-function-nodejs
gcp.pubsub.us-central1--cp--create-topic
gcp.pubsub.us-central1--cp--delete-topic
gcp.pubsub.us-central1--cp--read-topic
gcp.pubsub.us-central1--cp--subscribe
gcp.pubsub.us-central1--cp--unsubscribe
gcp.pubsub.us-central1--cp--update-topic
Data plane tests measure performance operations on existing cloud resources.
aws.bedrock.global--dp--converse-code-claude-haiku
aws.bedrock.global--dp--converse-code-claude-sonnet
aws.bedrock.global--dp--converse-code-gpt-luna
aws.bedrock.us-east-1--dp--converse-code-gpt-oss-120b
aws.bedrock.global--dp--converse-code-gpt-sol
aws.bedrock.global--dp--converse-fact-claude-haiku
aws.bedrock.global--dp--converse-fact-claude-sonnet
aws.bedrock.global--dp--converse-fact-gpt-luna
aws.bedrock.us-east-1--dp--converse-fact-gpt-oss-120b
aws.bedrock.global--dp--converse-fact-gpt-sol
aws.bedrock.global--dp--converse-math-claude-haiku
aws.bedrock.global--dp--converse-math-claude-sonnet
aws.bedrock.global--dp--converse-math-gpt-luna
aws.bedrock.us-east-1--dp--converse-math-gpt-oss-120b
aws.bedrock.global--dp--converse-math-gpt-sol
aws.bedrock.global--dp--converse-reasoning-claude-haiku
aws.bedrock.global--dp--converse-reasoning-claude-sonnet
aws.bedrock.global--dp--converse-reasoning-gpt-luna
aws.bedrock.us-east-1--dp--converse-reasoning-gpt-oss-120b
aws.bedrock.global--dp--converse-reasoning-gpt-sol
aws.dynamodb.us-east-1--dp--delete-item
aws.dynamodb.us-east-1--dp--get-item
aws.dynamodb.us-east-1--dp--put-item
aws.dynamodb.us-east-1--dp--update-item
aws.efs.us-east-1--dp--rand-read-efs-gp
aws.efs.us-east-1--dp--rand-read-efs-maxio
aws.ebs.us-east-1--dp--rand-read-gp2
aws.ebs.us-east-1--dp--rand-read-gp3
aws.ebs.us-east-1--dp--rand-read-io1
aws.ebs.us-east-1--dp--rand-read-io2
aws.ebs.us-east-1--dp--rand-read-sc1
aws.ebs.us-east-1--dp--rand-read-st1
aws.efs.us-east-1--dp--rand-write-efs-gp
aws.efs.us-east-1--dp--rand-write-efs-maxio
aws.ebs.us-east-1--dp--rand-write-gp2
aws.ebs.us-east-1--dp--rand-write-gp3
aws.ebs.us-east-1--dp--rand-write-io1
aws.ebs.us-east-1--dp--rand-write-io2
aws.ebs.us-east-1--dp--rand-write-sc1
aws.ebs.us-east-1--dp--rand-write-st1
aws.efs.us-east-1--dp--seq-read-efs-gp
aws.efs.us-east-1--dp--seq-read-efs-maxio
aws.ebs.us-east-1--dp--seq-read-gp2
aws.ebs.us-east-1--dp--seq-read-gp3
aws.ebs.us-east-1--dp--seq-read-io1
aws.ebs.us-east-1--dp--seq-read-io2
aws.ebs.us-east-1--dp--seq-read-sc1
aws.ebs.us-east-1--dp--seq-read-st1
aws.efs.us-east-1--dp--seq-write-efs-gp
aws.efs.us-east-1--dp--seq-write-efs-maxio
aws.ebs.us-east-1--dp--seq-write-gp2
aws.ebs.us-east-1--dp--seq-write-gp3
aws.ebs.us-east-1--dp--seq-write-io1
aws.ebs.us-east-1--dp--seq-write-io2
aws.ebs.us-east-1--dp--seq-write-sc1
aws.ebs.us-east-1--dp--seq-write-st1
aws.lambda.us-east-1--dp--invoke-function-after-update-dotnet
aws.lambda.us-east-1--dp--invoke-function-after-update-java
aws.lambda.us-east-1--dp--invoke-function-after-update-nodejs
aws.lambda.us-east-1--dp--invoke-function-after-update-python
aws.lambda.us-east-1--dp--invoke-function-after-update-ruby
aws.lambda.us-east-1--dp--invoke-function-dotnet
aws.lambda.us-east-1--dp--invoke-function-java
aws.lambda.us-east-1--dp--invoke-function-nodejs
aws.lambda.us-east-1--dp--invoke-function-python
aws.lambda.us-east-1--dp--invoke-function-ruby
aws.lambda.us-east-1--dp--invoke-function-warm-dotnet
aws.lambda.us-east-1--dp--invoke-function-warm-java
aws.lambda.us-east-1--dp--invoke-function-warm-nodejs
aws.lambda.us-east-1--dp--invoke-function-warm-python
aws.lambda.us-east-1--dp--invoke-function-warm-ruby
aws.s3.us-east-1--dp--copy-object-express-onezone
aws.s3.us-east-1--dp--copy-object-glacier-ir
aws.s3.us-east-1--dp--copy-object-onezone-ia
aws.s3.us-east-1--dp--copy-object-standard
aws.s3.us-east-1--dp--copy-object-standard-ia
aws.s3.us-east-1--dp--delete-object-express-onezone
aws.s3.us-east-1--dp--delete-object-glacier-ir
aws.s3.us-east-1--dp--delete-object-onezone-ia
aws.s3.us-east-1--dp--delete-object-standard
aws.s3.us-east-1--dp--delete-object-standard-ia
aws.s3.us-east-1--dp--get-object-express-onezone
aws.s3.us-east-1--dp--get-object-glacier-ir
aws.s3.us-east-1--dp--get-object-onezone-ia
aws.s3.us-east-1--dp--get-object-range-express-onezone
aws.s3.us-east-1--dp--get-object-range-glacier-ir
aws.s3.us-east-1--dp--get-object-range-onezone-ia
aws.s3.us-east-1--dp--get-object-range-standard
aws.s3.us-east-1--dp--get-object-range-standard-ia
aws.s3.us-east-1--dp--get-object-standard
aws.s3.us-east-1--dp--get-object-standard-ia
aws.s3.us-east-1--dp--head-object-express-onezone
aws.s3.us-east-1--dp--head-object-glacier-ir
aws.s3.us-east-1--dp--head-object-onezone-ia
aws.s3.us-east-1--dp--head-object-standard
aws.s3.us-east-1--dp--head-object-standard-ia
aws.s3.us-east-1--dp--put-object-express-onezone
aws.s3.us-east-1--dp--put-object-glacier-ir
aws.s3.us-east-1--dp--put-object-onezone-ia
aws.s3.us-east-1--dp--put-object-standard
aws.s3.us-east-1--dp--put-object-standard-ia
aws.sns.us-east-1--dp--publish
aws.sns.us-east-1--dp--receive-message
aws.sqs.us-east-1--dp--receive-message
aws.sqs.us-east-1--dp--send-message
gcp.aiplatform.global--dp--converse-code-gemini-flash
gcp.aiplatform.global--dp--converse-fact-gemini-flash
gcp.aiplatform.global--dp--converse-math-gemini-flash
gcp.aiplatform.global--dp--converse-reasoning-gemini-flash
gcp.aiplatform.global--dp--converse-code-gpt-oss-120b
gcp.aiplatform.global--dp--converse-fact-gpt-oss-120b
gcp.aiplatform.global--dp--converse-math-gpt-oss-120b
gcp.aiplatform.global--dp--converse-reasoning-gpt-oss-120b
gcp.firestore.us-central1--dp--delete-document
gcp.firestore.us-central1--dp--get-document
gcp.firestore.us-central1--dp--put-document
gcp.firestore.us-central1--dp--update-document
gcp.functions.us-central1--dp--invoke-function-after-update-nodejs
gcp.functions.us-central1--dp--invoke-function-warm-nodejs
gcp.pubsub.us-central1--dp--publish
gcp.pubsub.us-central1--dp--receive-message
Network Test Categories:
Tests within the same availability zone.
aws.ec2.us-east-1.use1-az1--dp--tcping4--aws.ec2.us-east-1.use1-az1
aws.ec2.us-east-1.use1-az1--dp--tcping4--aws.ec2.us-east-1.use1-az2
aws.ec2.us-east-1.use1-az1--dp--tcping4--aws.ec2.us-east-1.use1-az3
aws.ec2.us-east-1.use1-az1--dp--tcping4--aws.ec2.us-east-1.use1-az4
aws.ec2.us-east-1.use1-az1--dp--tcping4--aws.ec2.us-east-1.use1-az5
aws.ec2.us-east-1.use1-az1--dp--tcping4--aws.ec2.us-east-1.use1-az6
aws.ec2.us-east-1.use1-az1--dp--tcping6--aws.ec2.us-east-1.use1-az1
aws.ec2.us-east-1.use1-az1--dp--tcping6--aws.ec2.us-east-1.use1-az2
aws.ec2.us-east-1.use1-az1--dp--tcping6--aws.ec2.us-east-1.use1-az3
aws.ec2.us-east-1.use1-az1--dp--tcping6--aws.ec2.us-east-1.use1-az4
aws.ec2.us-east-1.use1-az1--dp--tcping6--aws.ec2.us-east-1.use1-az5
aws.ec2.us-east-1.use1-az1--dp--tcping6--aws.ec2.us-east-1.use1-az6
aws.ec2.us-east-1.use1-az2--dp--tcping4--aws.ec2.us-east-1.use1-az1
aws.ec2.us-east-1.use1-az2--dp--tcping4--aws.ec2.us-east-1.use1-az2
aws.ec2.us-east-1.use1-az2--dp--tcping4--aws.ec2.us-east-1.use1-az3
aws.ec2.us-east-1.use1-az2--dp--tcping4--aws.ec2.us-east-1.use1-az4
aws.ec2.us-east-1.use1-az2--dp--tcping4--aws.ec2.us-east-1.use1-az5
aws.ec2.us-east-1.use1-az2--dp--tcping4--aws.ec2.us-east-1.use1-az6
aws.ec2.us-east-1.use1-az2--dp--tcping6--aws.ec2.us-east-1.use1-az1
aws.ec2.us-east-1.use1-az2--dp--tcping6--aws.ec2.us-east-1.use1-az2
aws.ec2.us-east-1.use1-az2--dp--tcping6--aws.ec2.us-east-1.use1-az3
aws.ec2.us-east-1.use1-az2--dp--tcping6--aws.ec2.us-east-1.use1-az4
aws.ec2.us-east-1.use1-az2--dp--tcping6--aws.ec2.us-east-1.use1-az5
aws.ec2.us-east-1.use1-az2--dp--tcping6--aws.ec2.us-east-1.use1-az6
aws.ec2.us-east-1.use1-az3--dp--tcping4--aws.ec2.us-east-1.use1-az1
aws.ec2.us-east-1.use1-az3--dp--tcping4--aws.ec2.us-east-1.use1-az2
aws.ec2.us-east-1.use1-az3--dp--tcping4--aws.ec2.us-east-1.use1-az3
aws.ec2.us-east-1.use1-az3--dp--tcping4--aws.ec2.us-east-1.use1-az4
aws.ec2.us-east-1.use1-az3--dp--tcping4--aws.ec2.us-east-1.use1-az5
aws.ec2.us-east-1.use1-az3--dp--tcping4--aws.ec2.us-east-1.use1-az6
aws.ec2.us-east-1.use1-az3--dp--tcping6--aws.ec2.us-east-1.use1-az1
aws.ec2.us-east-1.use1-az3--dp--tcping6--aws.ec2.us-east-1.use1-az2
aws.ec2.us-east-1.use1-az3--dp--tcping6--aws.ec2.us-east-1.use1-az3
aws.ec2.us-east-1.use1-az3--dp--tcping6--aws.ec2.us-east-1.use1-az4
aws.ec2.us-east-1.use1-az3--dp--tcping6--aws.ec2.us-east-1.use1-az5
aws.ec2.us-east-1.use1-az3--dp--tcping6--aws.ec2.us-east-1.use1-az6
aws.ec2.us-east-1.use1-az4--dp--tcping4--aws.ec2.us-east-1.use1-az1
aws.ec2.us-east-1.use1-az4--dp--tcping4--aws.ec2.us-east-1.use1-az2
aws.ec2.us-east-1.use1-az4--dp--tcping4--aws.ec2.us-east-1.use1-az3
aws.ec2.us-east-1.use1-az4--dp--tcping4--aws.ec2.us-east-1.use1-az4
aws.ec2.us-east-1.use1-az4--dp--tcping4--aws.ec2.us-east-1.use1-az5
aws.ec2.us-east-1.use1-az4--dp--tcping4--aws.ec2.us-east-1.use1-az6
aws.ec2.us-east-1.use1-az4--dp--tcping6--aws.ec2.us-east-1.use1-az1
aws.ec2.us-east-1.use1-az4--dp--tcping6--aws.ec2.us-east-1.use1-az2
aws.ec2.us-east-1.use1-az4--dp--tcping6--aws.ec2.us-east-1.use1-az3
aws.ec2.us-east-1.use1-az4--dp--tcping6--aws.ec2.us-east-1.use1-az4
aws.ec2.us-east-1.use1-az4--dp--tcping6--aws.ec2.us-east-1.use1-az5
aws.ec2.us-east-1.use1-az4--dp--tcping6--aws.ec2.us-east-1.use1-az6
aws.ec2.us-east-1.use1-az5--dp--tcping4--aws.ec2.us-east-1.use1-az1
aws.ec2.us-east-1.use1-az5--dp--tcping4--aws.ec2.us-east-1.use1-az2
aws.ec2.us-east-1.use1-az5--dp--tcping4--aws.ec2.us-east-1.use1-az3
aws.ec2.us-east-1.use1-az5--dp--tcping4--aws.ec2.us-east-1.use1-az4
aws.ec2.us-east-1.use1-az5--dp--tcping4--aws.ec2.us-east-1.use1-az5
aws.ec2.us-east-1.use1-az5--dp--tcping4--aws.ec2.us-east-1.use1-az6
aws.ec2.us-east-1.use1-az5--dp--tcping6--aws.ec2.us-east-1.use1-az1
aws.ec2.us-east-1.use1-az5--dp--tcping6--aws.ec2.us-east-1.use1-az2
aws.ec2.us-east-1.use1-az5--dp--tcping6--aws.ec2.us-east-1.use1-az3
aws.ec2.us-east-1.use1-az5--dp--tcping6--aws.ec2.us-east-1.use1-az4
aws.ec2.us-east-1.use1-az5--dp--tcping6--aws.ec2.us-east-1.use1-az5
aws.ec2.us-east-1.use1-az5--dp--tcping6--aws.ec2.us-east-1.use1-az6
aws.ec2.us-east-1.use1-az6--dp--tcping4--aws.ec2.us-east-1.use1-az1
aws.ec2.us-east-1.use1-az6--dp--tcping4--aws.ec2.us-east-1.use1-az2
aws.ec2.us-east-1.use1-az6--dp--tcping4--aws.ec2.us-east-1.use1-az3
aws.ec2.us-east-1.use1-az6--dp--tcping4--aws.ec2.us-east-1.use1-az4
aws.ec2.us-east-1.use1-az6--dp--tcping4--aws.ec2.us-east-1.use1-az5
aws.ec2.us-east-1.use1-az6--dp--tcping4--aws.ec2.us-east-1.use1-az6
aws.ec2.us-east-1.use1-az6--dp--tcping6--aws.ec2.us-east-1.use1-az1
aws.ec2.us-east-1.use1-az6--dp--tcping6--aws.ec2.us-east-1.use1-az2
aws.ec2.us-east-1.use1-az6--dp--tcping6--aws.ec2.us-east-1.use1-az3
aws.ec2.us-east-1.use1-az6--dp--tcping6--aws.ec2.us-east-1.use1-az4
aws.ec2.us-east-1.use1-az6--dp--tcping6--aws.ec2.us-east-1.use1-az5
aws.ec2.us-east-1.use1-az6--dp--tcping6--aws.ec2.us-east-1.use1-az6
Tests between different services or zones within the same region of the same cloud provider (e.g., aws.ec2.us-east-1 to aws.s3.us-east-1).
aws.ec2.us-east-1--dp--http--aws.s3.us-east-1
aws.ec2.us-east-1--dp--httpsb-100mb--aws.s3.us-east-1
aws.ec2.us-east-1--dp--tcping4--aws.s3.us-east-1
aws.ec2.us-east-1--dp--tcping4--aws.us-east-1
aws.ec2.us-east-1--dp--tcping6--aws.us-east-1
aws.ec2.us-east-1.use1-az1--dp--tcping4--aws.ec2.us-east-1.use1-az1
aws.ec2.us-east-1.use1-az1--dp--tcping4--aws.ec2.us-east-1.use1-az2
aws.ec2.us-east-1.use1-az1--dp--tcping4--aws.ec2.us-east-1.use1-az3
aws.ec2.us-east-1.use1-az1--dp--tcping4--aws.ec2.us-east-1.use1-az4
aws.ec2.us-east-1.use1-az1--dp--tcping4--aws.ec2.us-east-1.use1-az5
aws.ec2.us-east-1.use1-az1--dp--tcping4--aws.ec2.us-east-1.use1-az6
aws.ec2.us-east-1.use1-az1--dp--tcping6--aws.ec2.us-east-1.use1-az1
aws.ec2.us-east-1.use1-az1--dp--tcping6--aws.ec2.us-east-1.use1-az2
aws.ec2.us-east-1.use1-az1--dp--tcping6--aws.ec2.us-east-1.use1-az3
aws.ec2.us-east-1.use1-az1--dp--tcping6--aws.ec2.us-east-1.use1-az4
aws.ec2.us-east-1.use1-az1--dp--tcping6--aws.ec2.us-east-1.use1-az5
aws.ec2.us-east-1.use1-az1--dp--tcping6--aws.ec2.us-east-1.use1-az6
aws.ec2.us-east-1.use1-az2--dp--tcping4--aws.ec2.us-east-1.use1-az1
aws.ec2.us-east-1.use1-az2--dp--tcping4--aws.ec2.us-east-1.use1-az2
aws.ec2.us-east-1.use1-az2--dp--tcping4--aws.ec2.us-east-1.use1-az3
aws.ec2.us-east-1.use1-az2--dp--tcping4--aws.ec2.us-east-1.use1-az4
aws.ec2.us-east-1.use1-az2--dp--tcping4--aws.ec2.us-east-1.use1-az5
aws.ec2.us-east-1.use1-az2--dp--tcping4--aws.ec2.us-east-1.use1-az6
aws.ec2.us-east-1.use1-az2--dp--tcping6--aws.ec2.us-east-1.use1-az1
aws.ec2.us-east-1.use1-az2--dp--tcping6--aws.ec2.us-east-1.use1-az2
aws.ec2.us-east-1.use1-az2--dp--tcping6--aws.ec2.us-east-1.use1-az3
aws.ec2.us-east-1.use1-az2--dp--tcping6--aws.ec2.us-east-1.use1-az4
aws.ec2.us-east-1.use1-az2--dp--tcping6--aws.ec2.us-east-1.use1-az5
aws.ec2.us-east-1.use1-az2--dp--tcping6--aws.ec2.us-east-1.use1-az6
aws.ec2.us-east-1.use1-az3--dp--tcping4--aws.ec2.us-east-1.use1-az1
aws.ec2.us-east-1.use1-az3--dp--tcping4--aws.ec2.us-east-1.use1-az2
aws.ec2.us-east-1.use1-az3--dp--tcping4--aws.ec2.us-east-1.use1-az3
aws.ec2.us-east-1.use1-az3--dp--tcping4--aws.ec2.us-east-1.use1-az4
aws.ec2.us-east-1.use1-az3--dp--tcping4--aws.ec2.us-east-1.use1-az5
aws.ec2.us-east-1.use1-az3--dp--tcping4--aws.ec2.us-east-1.use1-az6
aws.ec2.us-east-1.use1-az3--dp--tcping6--aws.ec2.us-east-1.use1-az1
aws.ec2.us-east-1.use1-az3--dp--tcping6--aws.ec2.us-east-1.use1-az2
aws.ec2.us-east-1.use1-az3--dp--tcping6--aws.ec2.us-east-1.use1-az3
aws.ec2.us-east-1.use1-az3--dp--tcping6--aws.ec2.us-east-1.use1-az4
aws.ec2.us-east-1.use1-az3--dp--tcping6--aws.ec2.us-east-1.use1-az5
aws.ec2.us-east-1.use1-az3--dp--tcping6--aws.ec2.us-east-1.use1-az6
aws.ec2.us-east-1.use1-az4--dp--tcping4--aws.ec2.us-east-1.use1-az1
aws.ec2.us-east-1.use1-az4--dp--tcping4--aws.ec2.us-east-1.use1-az2
aws.ec2.us-east-1.use1-az4--dp--tcping4--aws.ec2.us-east-1.use1-az3
aws.ec2.us-east-1.use1-az4--dp--tcping4--aws.ec2.us-east-1.use1-az4
aws.ec2.us-east-1.use1-az4--dp--tcping4--aws.ec2.us-east-1.use1-az5
aws.ec2.us-east-1.use1-az4--dp--tcping4--aws.ec2.us-east-1.use1-az6
aws.ec2.us-east-1.use1-az4--dp--tcping6--aws.ec2.us-east-1.use1-az1
aws.ec2.us-east-1.use1-az4--dp--tcping6--aws.ec2.us-east-1.use1-az2
aws.ec2.us-east-1.use1-az4--dp--tcping6--aws.ec2.us-east-1.use1-az3
aws.ec2.us-east-1.use1-az4--dp--tcping6--aws.ec2.us-east-1.use1-az4
aws.ec2.us-east-1.use1-az4--dp--tcping6--aws.ec2.us-east-1.use1-az5
aws.ec2.us-east-1.use1-az4--dp--tcping6--aws.ec2.us-east-1.use1-az6
aws.ec2.us-east-1.use1-az5--dp--tcping4--aws.ec2.us-east-1.use1-az1
aws.ec2.us-east-1.use1-az5--dp--tcping4--aws.ec2.us-east-1.use1-az2
aws.ec2.us-east-1.use1-az5--dp--tcping4--aws.ec2.us-east-1.use1-az3
aws.ec2.us-east-1.use1-az5--dp--tcping4--aws.ec2.us-east-1.use1-az4
aws.ec2.us-east-1.use1-az5--dp--tcping4--aws.ec2.us-east-1.use1-az5
aws.ec2.us-east-1.use1-az5--dp--tcping4--aws.ec2.us-east-1.use1-az6
aws.ec2.us-east-1.use1-az5--dp--tcping6--aws.ec2.us-east-1.use1-az1
aws.ec2.us-east-1.use1-az5--dp--tcping6--aws.ec2.us-east-1.use1-az2
aws.ec2.us-east-1.use1-az5--dp--tcping6--aws.ec2.us-east-1.use1-az3
aws.ec2.us-east-1.use1-az5--dp--tcping6--aws.ec2.us-east-1.use1-az4
aws.ec2.us-east-1.use1-az5--dp--tcping6--aws.ec2.us-east-1.use1-az5
aws.ec2.us-east-1.use1-az5--dp--tcping6--aws.ec2.us-east-1.use1-az6
aws.ec2.us-east-1.use1-az6--dp--tcping4--aws.ec2.us-east-1.use1-az1
aws.ec2.us-east-1.use1-az6--dp--tcping4--aws.ec2.us-east-1.use1-az2
aws.ec2.us-east-1.use1-az6--dp--tcping4--aws.ec2.us-east-1.use1-az3
aws.ec2.us-east-1.use1-az6--dp--tcping4--aws.ec2.us-east-1.use1-az4
aws.ec2.us-east-1.use1-az6--dp--tcping4--aws.ec2.us-east-1.use1-az5
aws.ec2.us-east-1.use1-az6--dp--tcping4--aws.ec2.us-east-1.use1-az6
aws.ec2.us-east-1.use1-az6--dp--tcping6--aws.ec2.us-east-1.use1-az1
aws.ec2.us-east-1.use1-az6--dp--tcping6--aws.ec2.us-east-1.use1-az2
aws.ec2.us-east-1.use1-az6--dp--tcping6--aws.ec2.us-east-1.use1-az3
aws.ec2.us-east-1.use1-az6--dp--tcping6--aws.ec2.us-east-1.use1-az4
aws.ec2.us-east-1.use1-az6--dp--tcping6--aws.ec2.us-east-1.use1-az5
aws.ec2.us-east-1.use1-az6--dp--tcping6--aws.ec2.us-east-1.use1-az6
Tests between different regions of the same cloud provider (e.g., aws.ec2.us-east-1 to aws.s3.eu-west-1).
aws.ca-central-1--dp--gping4--aws.us-east-1
aws.ca-central-1--dp--gping4--aws.us-east-2
aws.ca-central-1--dp--gping4--aws.us-west-1
aws.ca-central-1--dp--gping4--aws.us-west-2
aws.ec2.us-east-1--dp--http--aws.s3.af-south-1
aws.ec2.us-east-1--dp--http--aws.s3.ap-east-1
aws.ec2.us-east-1--dp--http--aws.s3.ap-northeast-1
aws.ec2.us-east-1--dp--http--aws.s3.ap-northeast-2
aws.ec2.us-east-1--dp--http--aws.s3.ap-northeast-3
aws.ec2.us-east-1--dp--http--aws.s3.ap-south-1
aws.ec2.us-east-1--dp--http--aws.s3.ap-south-2
aws.ec2.us-east-1--dp--http--aws.s3.ap-southeast-1
aws.ec2.us-east-1--dp--http--aws.s3.ap-southeast-2
aws.ec2.us-east-1--dp--http--aws.s3.ap-southeast-3
aws.ec2.us-east-1--dp--http--aws.s3.ap-southeast-4
aws.ec2.us-east-1--dp--http--aws.s3.ap-southeast-5
aws.ec2.us-east-1--dp--http--aws.s3.ap-southeast-7
aws.ec2.us-east-1--dp--http--aws.s3.ca-central-1
aws.ec2.us-east-1--dp--http--aws.s3.ca-west-1
aws.ec2.us-east-1--dp--http--aws.s3.eu-central-1
aws.ec2.us-east-1--dp--http--aws.s3.eu-central-2
aws.ec2.us-east-1--dp--http--aws.s3.eu-north-1
aws.ec2.us-east-1--dp--http--aws.s3.eu-south-1
aws.ec2.us-east-1--dp--http--aws.s3.eu-south-2
aws.ec2.us-east-1--dp--http--aws.s3.eu-west-1
aws.ec2.us-east-1--dp--http--aws.s3.eu-west-2
aws.ec2.us-east-1--dp--http--aws.s3.eu-west-3
aws.ec2.us-east-1--dp--http--aws.s3.il-central-1
aws.ec2.us-east-1--dp--http--aws.s3.me-central-1
aws.ec2.us-east-1--dp--http--aws.s3.me-south-1
aws.ec2.us-east-1--dp--http--aws.s3.mx-central-1
aws.ec2.us-east-1--dp--http--aws.s3.sa-east-1
aws.ec2.us-east-1--dp--http--aws.s3.us-east-2
aws.ec2.us-east-1--dp--http--aws.s3.us-west-1
aws.ec2.us-east-1--dp--http--aws.s3.us-west-2
aws.ec2.us-east-1--dp--httpsb-100mb--aws.s3.af-south-1
aws.ec2.us-east-1--dp--httpsb-100mb--aws.s3.ap-east-1
aws.ec2.us-east-1--dp--httpsb-100mb--aws.s3.ap-northeast-1
aws.ec2.us-east-1--dp--httpsb-100mb--aws.s3.ap-northeast-2
aws.ec2.us-east-1--dp--httpsb-100mb--aws.s3.ap-northeast-3
aws.ec2.us-east-1--dp--httpsb-100mb--aws.s3.ap-south-1
aws.ec2.us-east-1--dp--httpsb-100mb--aws.s3.ap-south-2
aws.ec2.us-east-1--dp--httpsb-100mb--aws.s3.ap-southeast-1
aws.ec2.us-east-1--dp--httpsb-100mb--aws.s3.ap-southeast-2
aws.ec2.us-east-1--dp--httpsb-100mb--aws.s3.ap-southeast-3
aws.ec2.us-east-1--dp--httpsb-100mb--aws.s3.ap-southeast-4
aws.ec2.us-east-1--dp--httpsb-100mb--aws.s3.ap-southeast-5
aws.ec2.us-east-1--dp--httpsb-100mb--aws.s3.ap-southeast-7
aws.ec2.us-east-1--dp--httpsb-100mb--aws.s3.ca-central-1
aws.ec2.us-east-1--dp--httpsb-100mb--aws.s3.ca-west-1
aws.ec2.us-east-1--dp--httpsb-100mb--aws.s3.eu-central-1
aws.ec2.us-east-1--dp--httpsb-100mb--aws.s3.eu-central-2
aws.ec2.us-east-1--dp--httpsb-100mb--aws.s3.eu-north-1
aws.ec2.us-east-1--dp--httpsb-100mb--aws.s3.eu-south-1
aws.ec2.us-east-1--dp--httpsb-100mb--aws.s3.eu-south-2
aws.ec2.us-east-1--dp--httpsb-100mb--aws.s3.eu-west-1
aws.ec2.us-east-1--dp--httpsb-100mb--aws.s3.eu-west-2
aws.ec2.us-east-1--dp--httpsb-100mb--aws.s3.eu-west-3
aws.ec2.us-east-1--dp--httpsb-100mb--aws.s3.il-central-1
aws.ec2.us-east-1--dp--httpsb-100mb--aws.s3.me-central-1
aws.ec2.us-east-1--dp--httpb-100mb--aws.s3.me-south-1
aws.ec2.us-east-1--dp--httpsb-100mb--aws.s3.mx-central-1
aws.ec2.us-east-1--dp--httpsb-100mb--aws.s3.sa-east-1
aws.ec2.us-east-1--dp--httpsb-100mb--aws.s3.us-east-2
aws.ec2.us-east-1--dp--httpsb-100mb--aws.s3.us-west-1
aws.ec2.us-east-1--dp--httpsb-100mb--aws.s3.us-west-2
aws.ec2.us-east-1--dp--tcping4--aws.af-south-1
aws.ec2.us-east-1--dp--tcping4--aws.af-south-1-los-1
aws.ec2.us-east-1--dp--tcping4--aws.ap-east-1
aws.ec2.us-east-1--dp--tcping4--aws.ap-northeast-1
aws.ec2.us-east-1--dp--tcping4--aws.ap-northeast-2
aws.ec2.us-east-1--dp--tcping4--aws.ap-northeast-3
aws.ec2.us-east-1--dp--tcping4--aws.ap-south-1
aws.ec2.us-east-1--dp--tcping4--aws.ap-south-2
aws.ec2.us-east-1--dp--tcping4--aws.ap-southeast-1
aws.ec2.us-east-1--dp--tcping4--aws.ap-southeast-2
aws.ec2.us-east-1--dp--tcping4--aws.ap-southeast-3
aws.ec2.us-east-1--dp--tcping4--aws.ap-southeast-4
aws.ec2.us-east-1--dp--tcping4--aws.ap-southeast-5
aws.ec2.us-east-1--dp--tcping4--aws.ap-southeast-7
aws.ec2.us-east-1--dp--tcping4--aws.ca-central-1
aws.ec2.us-east-1--dp--tcping4--aws.ca-west-1
aws.ec2.us-east-1--dp--tcping4--aws.eu-central-1
aws.ec2.us-east-1--dp--tcping4--aws.eu-central-2
aws.ec2.us-east-1--dp--tcping4--aws.eu-north-1
aws.ec2.us-east-1--dp--tcping4--aws.eu-south-1
aws.ec2.us-east-1--dp--tcping4--aws.eu-south-2
aws.ec2.us-east-1--dp--tcping4--aws.eu-west-1
aws.ec2.us-east-1--dp--tcping4--aws.eu-west-2
aws.ec2.us-east-1--dp--tcping4--aws.eu-west-3
aws.ec2.us-east-1--dp--tcping4--aws.il-central-1
aws.ec2.us-east-1--dp--tcping4--aws.me-central-1
aws.ec2.us-east-1--dp--tcping4--aws.me-south-1
aws.ec2.us-east-1--dp--tcping4--aws.me-south-1-mct-1
aws.ec2.us-east-1--dp--tcping4--aws.mx-central-1
aws.ec2.us-east-1--dp--tcping4--aws.s3.af-south-1
aws.ec2.us-east-1--dp--tcping4--aws.s3.ap-east-1
aws.ec2.us-east-1--dp--tcping4--aws.s3.ap-northeast-1
aws.ec2.us-east-1--dp--tcping4--aws.s3.ap-northeast-2
aws.ec2.us-east-1--dp--tcping4--aws.s3.ap-northeast-3
aws.ec2.us-east-1--dp--tcping4--aws.s3.ap-south-1
aws.ec2.us-east-1--dp--tcping4--aws.s3.ap-south-2
aws.ec2.us-east-1--dp--tcping4--aws.s3.ap-southeast-1
aws.ec2.us-east-1--dp--tcping4--aws.s3.ap-southeast-2
aws.ec2.us-east-1--dp--tcping4--aws.s3.ap-southeast-3
aws.ec2.us-east-1--dp--tcping4--aws.s3.ap-southeast-4
aws.ec2.us-east-1--dp--tcping4--aws.s3.ap-southeast-5
aws.ec2.us-east-1--dp--tcping4--aws.s3.ap-southeast-7
aws.ec2.us-east-1--dp--tcping4--aws.s3.ca-central-1
aws.ec2.us-east-1--dp--tcping4--aws.s3.ca-west-1
aws.ec2.us-east-1--dp--tcping4--aws.s3.eu-central-1
aws.ec2.us-east-1--dp--tcping4--aws.s3.eu-central-2
aws.ec2.us-east-1--dp--tcping4--aws.s3.eu-north-1
aws.ec2.us-east-1--dp--tcping4--aws.s3.eu-south-1
aws.ec2.us-east-1--dp--tcping4--aws.s3.eu-south-2
aws.ec2.us-east-1--dp--tcping4--aws.s3.eu-west-1
aws.ec2.us-east-1--dp--tcping4--aws.s3.eu-west-2
aws.ec2.us-east-1--dp--tcping4--aws.s3.eu-west-3
aws.ec2.us-east-1--dp--tcping4--aws.s3.il-central-1
aws.ec2.us-east-1--dp--tcping4--aws.s3.me-central-1
aws.ec2.us-east-1--dp--tcping4--aws.s3.me-south-1
aws.ec2.us-east-1--dp--tcping4--aws.s3.mx-central-1
aws.ec2.us-east-1--dp--tcping4--aws.s3.sa-east-1
aws.ec2.us-east-1--dp--tcping4--aws.s3.us-east-2
aws.ec2.us-east-1--dp--tcping4--aws.s3.us-west-1
aws.ec2.us-east-1--dp--tcping4--aws.s3.us-west-2
aws.ec2.us-east-1--dp--tcping4--aws.sa-east-1
aws.ec2.us-east-1--dp--tcping4--aws.us-east-2
aws.ec2.us-east-1--dp--tcping4--aws.us-gov-east-1
aws.ec2.us-east-1--dp--tcping4--aws.us-gov-west-1
aws.ec2.us-east-1--dp--tcping4--aws.us-west-1
aws.ec2.us-east-1--dp--tcping4--aws.us-west-2
aws.ec2.us-east-1--dp--tcping4--aws.us-west-2-lax-1
aws.ec2.us-east-1--dp--tcping6--aws.af-south-1
aws.ec2.us-east-1--dp--tcping6--aws.ap-east-1
aws.ec2.us-east-1--dp--tcping6--aws.ap-northeast-1
aws.ec2.us-east-1--dp--tcping6--aws.ap-northeast-2
aws.ec2.us-east-1--dp--tcping6--aws.ap-northeast-3
aws.ec2.us-east-1--dp--tcping6--aws.ap-south-1
aws.ec2.us-east-1--dp--tcping6--aws.ap-south-2
aws.ec2.us-east-1--dp--tcping6--aws.ap-southeast-1
aws.ec2.us-east-1--dp--tcping6--aws.ap-southeast-2
aws.ec2.us-east-1--dp--tcping6--aws.ap-southeast-3
aws.ec2.us-east-1--dp--tcping6--aws.ap-southeast-4
aws.ec2.us-east-1--dp--tcping6--aws.ap-southeast-5
aws.ec2.us-east-1--dp--tcping6--aws.ap-southeast-7
aws.ec2.us-east-1--dp--tcping6--aws.ca-central-1
aws.ec2.us-east-1--dp--tcping6--aws.ca-west-1
aws.ec2.us-east-1--dp--tcping6--aws.eu-central-1
aws.ec2.us-east-1--dp--tcping6--aws.eu-central-2
aws.ec2.us-east-1--dp--tcping6--aws.eu-north-1
aws.ec2.us-east-1--dp--tcping6--aws.eu-south-1
aws.ec2.us-east-1--dp--tcping6--aws.eu-south-2
aws.ec2.us-east-1--dp--tcping6--aws.eu-west-1
aws.ec2.us-east-1--dp--tcping6--aws.eu-west-2
aws.ec2.us-east-1--dp--tcping6--aws.eu-west-3
aws.ec2.us-east-1--dp--tcping6--aws.il-central-1
aws.ec2.us-east-1--dp--tcping6--aws.me-central-1
aws.ec2.us-east-1--dp--tcping6--aws.me-south-1
aws.ec2.us-east-1--dp--tcping6--aws.mx-central-1
aws.ec2.us-east-1--dp--tcping6--aws.sa-east-1
aws.ec2.us-east-1--dp--tcping6--aws.us-east-2
aws.ec2.us-east-1--dp--tcping6--aws.us-gov-east-1
aws.ec2.us-east-1--dp--tcping6--aws.us-gov-west-1
aws.ec2.us-east-1--dp--tcping6--aws.us-west-1
aws.ec2.us-east-1--dp--tcping6--aws.us-west-2
aws.ec2.us-east-1--dp--tcping6--aws.us-west-2-lax-1
aws.us-east-1--dp--gping4--aws.ca-central-1
aws.us-east-1--dp--gping4--aws.us-east-2
aws.us-east-1--dp--gping4--aws.us-west-1
aws.us-east-1--dp--gping4--aws.us-west-2
aws.us-east-2--dp--gping4--aws.ca-central-1
aws.us-east-2--dp--gping4--aws.us-east-1
aws.us-east-2--dp--gping4--aws.us-west-1
aws.us-east-2--dp--gping4--aws.us-west-2
aws.us-west-1--dp--gping4--aws.ca-central-1
aws.us-west-1--dp--gping4--aws.us-east-1
aws.us-west-1--dp--gping4--aws.us-east-2
aws.us-west-1--dp--gping4--aws.us-west-2
aws.us-west-2--dp--gping4--aws.ca-central-1
aws.us-west-2--dp--gping4--aws.us-east-1
aws.us-west-2--dp--gping4--aws.us-east-2
aws.us-west-2--dp--gping4--aws.us-west-1
Tests between cloud providers and global edge services (CDNs and DNS) that don't have a specific region.
aws.ec2.us-east-1--dp--dns--akamai.dns
aws.ec2.us-east-1--dp--dns--alibaba.dns
aws.ec2.us-east-1--dp--dns--aws.route53
aws.ec2.us-east-1--dp--dns--azure.dns
aws.ec2.us-east-1--dp--dns--bunny.dns
aws.ec2.us-east-1--dp--dns--cloudflare.dns
aws.ec2.us-east-1--dp--dns--digitalocean.dns
aws.ec2.us-east-1--dp--dns--dnsmadeeasy.dns
aws.ec2.us-east-1--dp--dns--easydns.dns
aws.ec2.us-east-1--dp--dns--gcp.dns
aws.ec2.us-east-1--dp--dns--ns1.dns
aws.ec2.us-east-1--dp--dns--rage4.dns
aws.ec2.us-east-1--dp--dns--ultradns.dns
aws.ec2.us-east-1--dp--http--akamai.cdn
aws.ec2.us-east-1--dp--http--alibaba.cdn
aws.ec2.us-east-1--dp--http--aws.cloudfront
aws.ec2.us-east-1--dp--http--azure.cdn
aws.ec2.us-east-1--dp--http--bunny.cdn
aws.ec2.us-east-1--dp--http--cachefly.cdn
aws.ec2.us-east-1--dp--http--cdnetworks.cdn
aws.ec2.us-east-1--dp--http--fastly.cdn
aws.ec2.us-east-1--dp--http--tencent.cdn
aws.ec2.us-east-1--dp--https--akamai.cdn
aws.ec2.us-east-1--dp--https--aws.cloudfront
aws.ec2.us-east-1--dp--https--azure.cdn
aws.ec2.us-east-1--dp--https--bunny.cdn
aws.ec2.us-east-1--dp--https--cachefly.cdn
aws.ec2.us-east-1--dp--https--cdnetworks.cdn
aws.ec2.us-east-1--dp--https--cloudflare.cdn
aws.ec2.us-east-1--dp--https--digitalocean.cdn
aws.ec2.us-east-1--dp--https--gcp.cdn
aws.ec2.us-east-1--dp--https--scaleway.cdn
aws.ec2.us-east-1--dp--tcping4--akamai.cdn
aws.ec2.us-east-1--dp--tcping4--alibaba.cdn
aws.ec2.us-east-1--dp--tcping4--aws.cloudfront
aws.ec2.us-east-1--dp--tcping4--azure.cdn
aws.ec2.us-east-1--dp--tcping4--bunny.cdn
aws.ec2.us-east-1--dp--tcping4--cachefly.cdn
aws.ec2.us-east-1--dp--tcping4--cdnetworks.cdn
aws.ec2.us-east-1--dp--tcping4--cloudflare.cdn
aws.ec2.us-east-1--dp--tcping4--digitalocean.cdn
aws.ec2.us-east-1--dp--tcping4--fastly.cdn
aws.ec2.us-east-1--dp--tcping4--gcp.cdn
aws.ec2.us-east-1--dp--tcping4--scaleway.cdn
aws.ec2.us-east-1--dp--tcping4--tencent.cdn
aws.ec2.us-east-1--dp--tcping6--aws.cloudfront
aws.ec2.us-east-1--dp--tcping6--azure.cdn
aws.ec2.us-east-1--dp--tcping6--cloudflare.cdn
aws.ec2.us-east-1--dp--tcping6--fastly.cdn
aws.ec2.us-east-1--dp--tcping6--gcp.cdn
aws.ec2.us-east-1--dp--tcping6--scaleway.cdn
aws.ec2.us-east-1--dp--tcping6--tencent.cdn
Tests between different cloud providers' regional services (e.g., aws.ec2.us-east-1 to azure.storage.eastus or gcp.storage.us-central1).
aws.ec2.us-east-1--dp--http--alibaba.oss.ap-northeast-1
aws.ec2.us-east-1--dp--http--alibaba.oss.ap-northeast-2
aws.ec2.us-east-1--dp--http--alibaba.oss.ap-southeast-1
aws.ec2.us-east-1--dp--http--alibaba.oss.ap-southeast-3
aws.ec2.us-east-1--dp--http--alibaba.oss.ap-southeast-5
aws.ec2.us-east-1--dp--http--alibaba.oss.ap-southeast-6
aws.ec2.us-east-1--dp--http--alibaba.oss.ap-southeast-7
aws.ec2.us-east-1--dp--http--alibaba.oss.eu-central-1
aws.ec2.us-east-1--dp--http--alibaba.oss.eu-west-1
aws.ec2.us-east-1--dp--http--alibaba.oss.me-central-1
aws.ec2.us-east-1--dp--http--alibaba.oss.me-east-1
aws.ec2.us-east-1--dp--http--alibaba.oss.na-south-1
aws.ec2.us-east-1--dp--http--alibaba.oss.us-east-1
aws.ec2.us-east-1--dp--http--alibaba.oss.us-west-1
aws.ec2.us-east-1--dp--http--azure.storage.australiacentral
aws.ec2.us-east-1--dp--http--azure.storage.australiaeast
aws.ec2.us-east-1--dp--http--azure.storage.australiasoutheast
aws.ec2.us-east-1--dp--http--azure.storage.brazilsouth
aws.ec2.us-east-1--dp--http--azure.storage.canadacentral
aws.ec2.us-east-1--dp--http--azure.storage.canadaeast
aws.ec2.us-east-1--dp--http--azure.storage.centralindia
aws.ec2.us-east-1--dp--http--azure.storage.centralus
aws.ec2.us-east-1--dp--http--azure.storage.eastasia
aws.ec2.us-east-1--dp--http--azure.storage.eastus
aws.ec2.us-east-1--dp--http--azure.storage.eastus2
aws.ec2.us-east-1--dp--http--azure.storage.francecentral
aws.ec2.us-east-1--dp--http--azure.storage.germanywestcentral
aws.ec2.us-east-1--dp--http--azure.storage.israelcentral
aws.ec2.us-east-1--dp--http--azure.storage.italynorth
aws.ec2.us-east-1--dp--http--azure.storage.japaneast
aws.ec2.us-east-1--dp--http--azure.storage.japanwest
aws.ec2.us-east-1--dp--http--azure.storage.koreacentral
aws.ec2.us-east-1--dp--http--azure.storage.koreasouth
aws.ec2.us-east-1--dp--http--azure.storage.mexicocentral
aws.ec2.us-east-1--dp--http--azure.storage.newzealandnorth
aws.ec2.us-east-1--dp--http--azure.storage.northcentralus
aws.ec2.us-east-1--dp--http--azure.storage.northeurope
aws.ec2.us-east-1--dp--http--azure.storage.norwayeast
aws.ec2.us-east-1--dp--http--azure.storage.polandcentral
aws.ec2.us-east-1--dp--http--azure.storage.qatarcentral
aws.ec2.us-east-1--dp--http--azure.storage.southafricanorth
aws.ec2.us-east-1--dp--http--azure.storage.southcentralus
aws.ec2.us-east-1--dp--http--azure.storage.southeastasia
aws.ec2.us-east-1--dp--http--azure.storage.southindia
aws.ec2.us-east-1--dp--http--azure.storage.spaincentral
aws.ec2.us-east-1--dp--http--azure.storage.swedencentral
aws.ec2.us-east-1--dp--http--azure.storage.switzerlandnorth
aws.ec2.us-east-1--dp--http--azure.storage.uaenorth
aws.ec2.us-east-1--dp--http--azure.storage.uksouth
aws.ec2.us-east-1--dp--http--azure.storage.ukwest
aws.ec2.us-east-1--dp--http--azure.storage.westcentralus
aws.ec2.us-east-1--dp--http--azure.storage.westeurope
aws.ec2.us-east-1--dp--http--azure.storage.westindia
aws.ec2.us-east-1--dp--http--azure.storage.westus
aws.ec2.us-east-1--dp--http--azure.storage.westus2
aws.ec2.us-east-1--dp--http--azure.storage.westus3
aws.ec2.us-east-1--dp--http--gcp.gcs.africa-south1
aws.ec2.us-east-1--dp--http--gcp.gcs.asia
aws.ec2.us-east-1--dp--http--gcp.gcs.asia-east1
aws.ec2.us-east-1--dp--http--gcp.gcs.asia-east2
aws.ec2.us-east-1--dp--http--gcp.gcs.asia-northeast1
aws.ec2.us-east-1--dp--http--gcp.gcs.asia-northeast2
aws.ec2.us-east-1--dp--http--gcp.gcs.asia-northeast3
aws.ec2.us-east-1--dp--http--gcp.gcs.asia-south1
aws.ec2.us-east-1--dp--http--gcp.gcs.asia-south2
aws.ec2.us-east-1--dp--http--gcp.gcs.asia-southeast1
aws.ec2.us-east-1--dp--http--gcp.gcs.asia-southeast2
aws.ec2.us-east-1--dp--http--gcp.gcs.australia-southeast1
aws.ec2.us-east-1--dp--http--gcp.gcs.australia-southeast2
aws.ec2.us-east-1--dp--http--gcp.gcs.eu
aws.ec2.us-east-1--dp--http--gcp.gcs.europe-central2
aws.ec2.us-east-1--dp--http--gcp.gcs.europe-north1
aws.ec2.us-east-1--dp--http--gcp.gcs.europe-southwest1
aws.ec2.us-east-1--dp--http--gcp.gcs.europe-west1
aws.ec2.us-east-1--dp--http--gcp.gcs.europe-west10
aws.ec2.us-east-1--dp--http--gcp.gcs.europe-west12
aws.ec2.us-east-1--dp--http--gcp.gcs.europe-west2
aws.ec2.us-east-1--dp--http--gcp.gcs.europe-west3
aws.ec2.us-east-1--dp--http--gcp.gcs.europe-west4
aws.ec2.us-east-1--dp--http--gcp.gcs.europe-west6
aws.ec2.us-east-1--dp--http--gcp.gcs.europe-west8
aws.ec2.us-east-1--dp--http--gcp.gcs.europe-west9
aws.ec2.us-east-1--dp--http--gcp.gcs.me-central1
aws.ec2.us-east-1--dp--http--gcp.gcs.me-west1
aws.ec2.us-east-1--dp--http--gcp.gcs.northamerica-northeast1
aws.ec2.us-east-1--dp--http--gcp.gcs.northamerica-northeast2
aws.ec2.us-east-1--dp--http--gcp.gcs.northamerica-south1
aws.ec2.us-east-1--dp--http--gcp.gcs.southamerica-east1
aws.ec2.us-east-1--dp--http--gcp.gcs.southamerica-west1
aws.ec2.us-east-1--dp--http--gcp.gcs.us
aws.ec2.us-east-1--dp--http--gcp.gcs.us-central1
aws.ec2.us-east-1--dp--http--gcp.gcs.us-east1
aws.ec2.us-east-1--dp--http--gcp.gcs.us-east4
aws.ec2.us-east-1--dp--http--gcp.gcs.us-east5
aws.ec2.us-east-1--dp--http--gcp.gcs.us-south1
aws.ec2.us-east-1--dp--http--gcp.gcs.us-west1
aws.ec2.us-east-1--dp--http--gcp.gcs.us-west2
aws.ec2.us-east-1--dp--http--gcp.gcs.us-west3
aws.ec2.us-east-1--dp--http--ibm.cos.ap-geo
aws.ec2.us-east-1--dp--http--ibm.cos.au-syd
aws.ec2.us-east-1--dp--http--ibm.cos.br-sao
aws.ec2.us-east-1--dp--http--ibm.cos.ca-tor
aws.ec2.us-east-1--dp--http--ibm.cos.eu-de
aws.ec2.us-east-1--dp--http--ibm.cos.eu-es
aws.ec2.us-east-1--dp--http--ibm.cos.eu-gb
aws.ec2.us-east-1--dp--http--ibm.cos.eu-geo
aws.ec2.us-east-1--dp--http--ibm.cos.jp-osa
aws.ec2.us-east-1--dp--http--ibm.cos.jp-tok
aws.ec2.us-east-1--dp--http--ibm.cos.us-east
aws.ec2.us-east-1--dp--http--ibm.cos.us-geo
aws.ec2.us-east-1--dp--http--ibm.cos.us-south
aws.ec2.us-east-1--dp--http--ionos.cos.de
aws.ec2.us-east-1--dp--http--ionos.cos.eu-central-2
aws.ec2.us-east-1--dp--http--ionos.cos.eu-central-3
aws.ec2.us-east-1--dp--http--ionos.cos.eu-south-2
aws.ec2.us-east-1--dp--http--ionos.cos.us-central-1
aws.ec2.us-east-1--dp--http--linode.storage.ap-south
aws.ec2.us-east-1--dp--http--linode.storage.au-mel
aws.ec2.us-east-1--dp--http--linode.storage.br-gru
aws.ec2.us-east-1--dp--http--linode.storage.es-mad
aws.ec2.us-east-1--dp--http--linode.storage.eu-central
aws.ec2.us-east-1--dp--http--linode.storage.fr-par
aws.ec2.us-east-1--dp--http--linode.storage.gb-lon
aws.ec2.us-east-1--dp--http--linode.storage.id-cgk
aws.ec2.us-east-1--dp--http--linode.storage.in-maa
aws.ec2.us-east-1--dp--http--linode.storage.it-mil
aws.ec2.us-east-1--dp--http--linode.storage.jp-osa
aws.ec2.us-east-1--dp--http--linode.storage.nl-ams
aws.ec2.us-east-1--dp--http--linode.storage.se-sto
aws.ec2.us-east-1--dp--http--linode.storage.sg-sin
aws.ec2.us-east-1--dp--http--linode.storage.us-east
aws.ec2.us-east-1--dp--http--linode.storage.us-iad
aws.ec2.us-east-1--dp--http--linode.storage.us-lax
aws.ec2.us-east-1--dp--http--linode.storage.us-mia
aws.ec2.us-east-1--dp--http--linode.storage.us-ord
aws.ec2.us-east-1--dp--http--linode.storage.us-sea
aws.ec2.us-east-1--dp--http--linode.storage.us-southeast
aws.ec2.us-east-1--dp--http--scaleway.cos.fr-par
aws.ec2.us-east-1--dp--http--scaleway.cos.nl-ams
aws.ec2.us-east-1--dp--http--scaleway.cos.pl-waw
aws.ec2.us-east-1--dp--http--tencent.cos.ap-bangkok
aws.ec2.us-east-1--dp--http--tencent.cos.ap-jakarta
aws.ec2.us-east-1--dp--http--tencent.cos.ap-seoul
aws.ec2.us-east-1--dp--http--tencent.cos.ap-singapore
aws.ec2.us-east-1--dp--http--tencent.cos.ap-tokyo
aws.ec2.us-east-1--dp--http--tencent.cos.eu-frankfurt
aws.ec2.us-east-1--dp--http--tencent.cos.na-ashburn
aws.ec2.us-east-1--dp--http--tencent.cos.na-siliconvalley
aws.ec2.us-east-1--dp--http--tencent.cos.sa-saopaulo
aws.ec2.us-east-1--dp--http--upcloud.cos.us-1
aws.ec2.us-east-1--dp--httpsb-100mb--alibaba.oss.ap-northeast-1
aws.ec2.us-east-1--dp--httpsb-100mb--alibaba.oss.ap-northeast-2
aws.ec2.us-east-1--dp--httpsb-100mb--alibaba.oss.ap-southeast-1
aws.ec2.us-east-1--dp--httpsb-100mb--alibaba.oss.ap-southeast-3
aws.ec2.us-east-1--dp--httpsb-100mb--alibaba.oss.ap-southeast-5
aws.ec2.us-east-1--dp--httpsb-100mb--alibaba.oss.ap-southeast-6
aws.ec2.us-east-1--dp--httpsb-100mb--alibaba.oss.ap-southeast-7
aws.ec2.us-east-1--dp--httpsb-100mb--alibaba.oss.eu-central-1
aws.ec2.us-east-1--dp--httpsb-100mb--alibaba.oss.eu-west-1
aws.ec2.us-east-1--dp--httpsb-100mb--alibaba.oss.me-central-1
aws.ec2.us-east-1--dp--httpsb-100mb--alibaba.oss.me-east-1
aws.ec2.us-east-1--dp--httpsb-100mb--alibaba.oss.na-south-1
aws.ec2.us-east-1--dp--httpsb-100mb--alibaba.oss.us-east-1
aws.ec2.us-east-1--dp--httpsb-100mb--alibaba.oss.us-west-1
aws.ec2.us-east-1--dp--httpsb-100mb--azure.storage.australiacentral
aws.ec2.us-east-1--dp--httpsb-100mb--azure.storage.australiaeast
aws.ec2.us-east-1--dp--httpsb-100mb--azure.storage.australiasoutheast
aws.ec2.us-east-1--dp--httpsb-100mb--azure.storage.brazilsouth
aws.ec2.us-east-1--dp--httpsb-100mb--azure.storage.canadacentral
aws.ec2.us-east-1--dp--httpsb-100mb--azure.storage.canadaeast
aws.ec2.us-east-1--dp--httpsb-100mb--azure.storage.centralindia
aws.ec2.us-east-1--dp--httpsb-100mb--azure.storage.centralus
aws.ec2.us-east-1--dp--httpsb-100mb--azure.storage.eastasia
aws.ec2.us-east-1--dp--httpsb-100mb--azure.storage.eastus
aws.ec2.us-east-1--dp--httpsb-100mb--azure.storage.eastus2
aws.ec2.us-east-1--dp--httpsb-100mb--azure.storage.francecentral
aws.ec2.us-east-1--dp--httpsb-100mb--azure.storage.germanywestcentral
aws.ec2.us-east-1--dp--httpsb-100mb--azure.storage.israelcentral
aws.ec2.us-east-1--dp--httpsb-100mb--azure.storage.italynorth
aws.ec2.us-east-1--dp--httpsb-100mb--azure.storage.japaneast
aws.ec2.us-east-1--dp--httpsb-100mb--azure.storage.japanwest
aws.ec2.us-east-1--dp--httpsb-100mb--azure.storage.koreacentral
aws.ec2.us-east-1--dp--httpsb-100mb--azure.storage.koreasouth
aws.ec2.us-east-1--dp--httpsb-100mb--azure.storage.mexicocentral
aws.ec2.us-east-1--dp--httpsb-100mb--azure.storage.newzealandnorth
aws.ec2.us-east-1--dp--httpsb-100mb--azure.storage.northcentralus
aws.ec2.us-east-1--dp--httpsb-100mb--azure.storage.northeurope
aws.ec2.us-east-1--dp--httpsb-100mb--azure.storage.norwayeast
aws.ec2.us-east-1--dp--httpsb-100mb--azure.storage.polandcentral
aws.ec2.us-east-1--dp--httpsb-100mb--azure.storage.qatarcentral
aws.ec2.us-east-1--dp--httpsb-100mb--azure.storage.southafricanorth
aws.ec2.us-east-1--dp--httpsb-100mb--azure.storage.southcentralus
aws.ec2.us-east-1--dp--httpsb-100mb--azure.storage.southeastasia
aws.ec2.us-east-1--dp--httpsb-100mb--azure.storage.southindia
aws.ec2.us-east-1--dp--httpsb-100mb--azure.storage.spaincentral
aws.ec2.us-east-1--dp--httpsb-100mb--azure.storage.swedencentral
aws.ec2.us-east-1--dp--httpsb-100mb--azure.storage.switzerlandnorth
aws.ec2.us-east-1--dp--httpsb-100mb--azure.storage.uaenorth
aws.ec2.us-east-1--dp--httpsb-100mb--azure.storage.uksouth
aws.ec2.us-east-1--dp--httpsb-100mb--azure.storage.ukwest
aws.ec2.us-east-1--dp--httpsb-100mb--azure.storage.westcentralus
aws.ec2.us-east-1--dp--httpsb-100mb--azure.storage.westeurope
aws.ec2.us-east-1--dp--httpsb-100mb--azure.storage.westindia
aws.ec2.us-east-1--dp--httpsb-100mb--azure.storage.westus
aws.ec2.us-east-1--dp--httpsb-100mb--azure.storage.westus2
aws.ec2.us-east-1--dp--httpsb-100mb--azure.storage.westus3
aws.ec2.us-east-1--dp--httpb-100mb--gcp.gcs.africa-south1
aws.ec2.us-east-1--dp--httpsb-100mb--gcp.gcs.asia
aws.ec2.us-east-1--dp--httpb-100mb--gcp.gcs.asia-east1
aws.ec2.us-east-1--dp--httpb-100mb--gcp.gcs.asia-east2
aws.ec2.us-east-1--dp--httpb-100mb--gcp.gcs.asia-northeast1
aws.ec2.us-east-1--dp--httpb-100mb--gcp.gcs.asia-northeast2
aws.ec2.us-east-1--dp--httpb-100mb--gcp.gcs.asia-northeast3
aws.ec2.us-east-1--dp--httpb-100mb--gcp.gcs.asia-south1
aws.ec2.us-east-1--dp--httpb-100mb--gcp.gcs.asia-south2
aws.ec2.us-east-1--dp--httpb-100mb--gcp.gcs.asia-southeast1
aws.ec2.us-east-1--dp--httpb-100mb--gcp.gcs.asia-southeast2
aws.ec2.us-east-1--dp--httpb-100mb--gcp.gcs.australia-southeast1
aws.ec2.us-east-1--dp--httpb-100mb--gcp.gcs.australia-southeast2
aws.ec2.us-east-1--dp--httpb-100mb--gcp.gcs.eu
aws.ec2.us-east-1--dp--httpb-100mb--gcp.gcs.europe-central2
aws.ec2.us-east-1--dp--httpb-100mb--gcp.gcs.europe-north1
aws.ec2.us-east-1--dp--httpb-100mb--gcp.gcs.europe-southwest1
aws.ec2.us-east-1--dp--httpb-100mb--gcp.gcs.europe-west1
aws.ec2.us-east-1--dp--httpb-100mb--gcp.gcs.europe-west10
aws.ec2.us-east-1--dp--httpb-100mb--gcp.gcs.europe-west12
aws.ec2.us-east-1--dp--httpb-100mb--gcp.gcs.europe-west2
aws.ec2.us-east-1--dp--httpb-100mb--gcp.gcs.europe-west3
aws.ec2.us-east-1--dp--httpb-100mb--gcp.gcs.europe-west4
aws.ec2.us-east-1--dp--httpb-100mb--gcp.gcs.europe-west6
aws.ec2.us-east-1--dp--httpb-100mb--gcp.gcs.europe-west8
aws.ec2.us-east-1--dp--httpb-100mb--gcp.gcs.europe-west9
aws.ec2.us-east-1--dp--httpb-100mb--gcp.gcs.me-central1
aws.ec2.us-east-1--dp--httpb-100mb--gcp.gcs.me-west1
aws.ec2.us-east-1--dp--httpb-100mb--gcp.gcs.northamerica-northeast1
aws.ec2.us-east-1--dp--httpb-100mb--gcp.gcs.northamerica-northeast2
aws.ec2.us-east-1--dp--httpb-100mb--gcp.gcs.northamerica-south1
aws.ec2.us-east-1--dp--httpb-100mb--gcp.gcs.southamerica-east1
aws.ec2.us-east-1--dp--httpb-100mb--gcp.gcs.southamerica-west1
aws.ec2.us-east-1--dp--httpb-100mb--gcp.gcs.us
aws.ec2.us-east-1--dp--httpb-100mb--gcp.gcs.us-central1
aws.ec2.us-east-1--dp--httpb-100mb--gcp.gcs.us-east1
aws.ec2.us-east-1--dp--httpb-100mb--gcp.gcs.us-east4
aws.ec2.us-east-1--dp--httpb-100mb--gcp.gcs.us-east5
aws.ec2.us-east-1--dp--httpb-100mb--gcp.gcs.us-south1
aws.ec2.us-east-1--dp--httpb-100mb--gcp.gcs.us-west1
aws.ec2.us-east-1--dp--httpb-100mb--gcp.gcs.us-west2
aws.ec2.us-east-1--dp--httpb-100mb--gcp.gcs.us-west3
aws.ec2.us-east-1--dp--httpsb-100mb--ibm.cos.ap-geo
aws.ec2.us-east-1--dp--httpsb-100mb--ibm.cos.au-syd
aws.ec2.us-east-1--dp--httpsb-100mb--ibm.cos.br-sao
aws.ec2.us-east-1--dp--httpsb-100mb--ibm.cos.ca-tor
aws.ec2.us-east-1--dp--httpsb-100mb--ibm.cos.eu-de
aws.ec2.us-east-1--dp--httpsb-100mb--ibm.cos.eu-es
aws.ec2.us-east-1--dp--httpsb-100mb--ibm.cos.eu-gb
aws.ec2.us-east-1--dp--httpsb-100mb--ibm.cos.eu-geo
aws.ec2.us-east-1--dp--httpsb-100mb--ibm.cos.jp-osa
aws.ec2.us-east-1--dp--httpsb-100mb--ibm.cos.jp-tok
aws.ec2.us-east-1--dp--httpsb-100mb--ibm.cos.us-east
aws.ec2.us-east-1--dp--httpsb-100mb--ibm.cos.us-geo
aws.ec2.us-east-1--dp--httpsb-100mb--ibm.cos.us-south
aws.ec2.us-east-1--dp--httpsb-100mb--ionos.cos.de
aws.ec2.us-east-1--dp--httpsb-100mb--ionos.cos.eu-central-2
aws.ec2.us-east-1--dp--httpsb-100mb--ionos.cos.eu-central-3
aws.ec2.us-east-1--dp--httpsb-100mb--ionos.cos.eu-south-2
aws.ec2.us-east-1--dp--httpsb-100mb--ionos.cos.us-central-1
aws.ec2.us-east-1--dp--httpsb-100mb--linode.storage.ap-south
aws.ec2.us-east-1--dp--httpsb-100mb--linode.storage.au-mel
aws.ec2.us-east-1--dp--httpsb-100mb--linode.storage.br-gru
aws.ec2.us-east-1--dp--httpsb-100mb--linode.storage.es-mad
aws.ec2.us-east-1--dp--httpsb-100mb--linode.storage.eu-central
aws.ec2.us-east-1--dp--httpsb-100mb--linode.storage.fr-par
aws.ec2.us-east-1--dp--httpsb-100mb--linode.storage.gb-lon
aws.ec2.us-east-1--dp--httpsb-100mb--linode.storage.id-cgk
aws.ec2.us-east-1--dp--httpsb-100mb--linode.storage.in-maa
aws.ec2.us-east-1--dp--httpsb-100mb--linode.storage.it-mil
aws.ec2.us-east-1--dp--httpsb-100mb--linode.storage.jp-osa
aws.ec2.us-east-1--dp--httpsb-100mb--linode.storage.nl-ams
aws.ec2.us-east-1--dp--httpsb-100mb--linode.storage.se-sto
aws.ec2.us-east-1--dp--httpsb-100mb--linode.storage.sg-sin
aws.ec2.us-east-1--dp--httpsb-100mb--linode.storage.us-east
aws.ec2.us-east-1--dp--httpsb-100mb--linode.storage.us-iad
aws.ec2.us-east-1--dp--httpsb-100mb--linode.storage.us-lax
aws.ec2.us-east-1--dp--httpsb-100mb--linode.storage.us-mia
aws.ec2.us-east-1--dp--httpsb-100mb--linode.storage.us-ord
aws.ec2.us-east-1--dp--httpsb-100mb--linode.storage.us-sea
aws.ec2.us-east-1--dp--httpsb-100mb--linode.storage.us-southeast
aws.ec2.us-east-1--dp--httpsb-100mb--scaleway.cos.fr-par
aws.ec2.us-east-1--dp--httpsb-100mb--scaleway.cos.nl-ams
aws.ec2.us-east-1--dp--httpsb-100mb--scaleway.cos.pl-waw
aws.ec2.us-east-1--dp--httpsb-100mb--tencent.cos.ap-bangkok
aws.ec2.us-east-1--dp--httpsb-100mb--tencent.cos.ap-jakarta
aws.ec2.us-east-1--dp--httpsb-100mb--tencent.cos.ap-seoul
aws.ec2.us-east-1--dp--httpsb-100mb--tencent.cos.ap-singapore
aws.ec2.us-east-1--dp--httpsb-100mb--tencent.cos.ap-tokyo
aws.ec2.us-east-1--dp--httpsb-100mb--tencent.cos.eu-frankfurt
aws.ec2.us-east-1--dp--httpsb-100mb--tencent.cos.na-ashburn
aws.ec2.us-east-1--dp--httpsb-100mb--tencent.cos.na-siliconvalley
aws.ec2.us-east-1--dp--httpsb-100mb--tencent.cos.sa-saopaulo
aws.ec2.us-east-1--dp--httpsb-100mb--upcloud.cos.us-1
aws.ec2.us-east-1--dp--https--alibaba.oss.ap-northeast-1
aws.ec2.us-east-1--dp--https--alibaba.oss.ap-northeast-2
aws.ec2.us-east-1--dp--https--alibaba.oss.ap-southeast-1
aws.ec2.us-east-1--dp--https--alibaba.oss.ap-southeast-3
aws.ec2.us-east-1--dp--https--alibaba.oss.ap-southeast-5
aws.ec2.us-east-1--dp--https--alibaba.oss.ap-southeast-6
aws.ec2.us-east-1--dp--https--alibaba.oss.ap-southeast-7
aws.ec2.us-east-1--dp--https--alibaba.oss.eu-central-1
aws.ec2.us-east-1--dp--https--alibaba.oss.eu-west-1
aws.ec2.us-east-1--dp--https--alibaba.oss.me-central-1
aws.ec2.us-east-1--dp--https--alibaba.oss.me-east-1
aws.ec2.us-east-1--dp--https--alibaba.oss.na-south-1
aws.ec2.us-east-1--dp--https--alibaba.oss.us-east-1
aws.ec2.us-east-1--dp--https--alibaba.oss.us-west-1
aws.ec2.us-east-1--dp--https--azure.storage.australiacentral
aws.ec2.us-east-1--dp--https--azure.storage.australiaeast
aws.ec2.us-east-1--dp--https--azure.storage.australiasoutheast
aws.ec2.us-east-1--dp--https--azure.storage.brazilsouth
aws.ec2.us-east-1--dp--https--azure.storage.canadacentral
aws.ec2.us-east-1--dp--https--azure.storage.canadaeast
aws.ec2.us-east-1--dp--https--azure.storage.centralindia
aws.ec2.us-east-1--dp--https--azure.storage.centralus
aws.ec2.us-east-1--dp--https--azure.storage.eastasia
aws.ec2.us-east-1--dp--https--azure.storage.eastus
aws.ec2.us-east-1--dp--https--azure.storage.eastus2
aws.ec2.us-east-1--dp--https--azure.storage.francecentral
aws.ec2.us-east-1--dp--https--azure.storage.germanywestcentral
aws.ec2.us-east-1--dp--https--azure.storage.israelcentral
aws.ec2.us-east-1--dp--https--azure.storage.italynorth
aws.ec2.us-east-1--dp--https--azure.storage.japaneast
aws.ec2.us-east-1--dp--https--azure.storage.japanwest
aws.ec2.us-east-1--dp--https--azure.storage.koreacentral
aws.ec2.us-east-1--dp--https--azure.storage.koreasouth
aws.ec2.us-east-1--dp--https--azure.storage.mexicocentral
aws.ec2.us-east-1--dp--https--azure.storage.newzealandnorth
aws.ec2.us-east-1--dp--https--azure.storage.northcentralus
aws.ec2.us-east-1--dp--https--azure.storage.northeurope
aws.ec2.us-east-1--dp--https--azure.storage.norwayeast
aws.ec2.us-east-1--dp--https--azure.storage.polandcentral
aws.ec2.us-east-1--dp--https--azure.storage.qatarcentral
aws.ec2.us-east-1--dp--https--azure.storage.southafricanorth
aws.ec2.us-east-1--dp--https--azure.storage.southcentralus
aws.ec2.us-east-1--dp--https--azure.storage.southeastasia
aws.ec2.us-east-1--dp--https--azure.storage.southindia
aws.ec2.us-east-1--dp--https--azure.storage.spaincentral
aws.ec2.us-east-1--dp--https--azure.storage.swedencentral
aws.ec2.us-east-1--dp--https--azure.storage.switzerlandnorth
aws.ec2.us-east-1--dp--https--azure.storage.uaenorth
aws.ec2.us-east-1--dp--https--azure.storage.uksouth
aws.ec2.us-east-1--dp--https--azure.storage.ukwest
aws.ec2.us-east-1--dp--https--azure.storage.westcentralus
aws.ec2.us-east-1--dp--https--azure.storage.westeurope
aws.ec2.us-east-1--dp--https--azure.storage.westindia
aws.ec2.us-east-1--dp--https--azure.storage.westus
aws.ec2.us-east-1--dp--https--azure.storage.westus2
aws.ec2.us-east-1--dp--https--azure.storage.westus3
aws.ec2.us-east-1--dp--https--cloudflare.r2.eu
aws.ec2.us-east-1--dp--https--cloudflare.r2.wnam
aws.ec2.us-east-1--dp--https--digitalocean.spaces.ams3
aws.ec2.us-east-1--dp--https--digitalocean.spaces.blr1
aws.ec2.us-east-1--dp--https--digitalocean.spaces.fra1
aws.ec2.us-east-1--dp--https--digitalocean.spaces.lon1
aws.ec2.us-east-1--dp--https--digitalocean.spaces.nyc3
aws.ec2.us-east-1--dp--https--digitalocean.spaces.sfo2
aws.ec2.us-east-1--dp--https--digitalocean.spaces.sfo3
aws.ec2.us-east-1--dp--https--digitalocean.spaces.sgp1
aws.ec2.us-east-1--dp--https--digitalocean.spaces.syd1
aws.ec2.us-east-1--dp--https--digitalocean.spaces.tor1
aws.ec2.us-east-1--dp--https--gcp.gcs.africa-south1
aws.ec2.us-east-1--dp--https--gcp.gcs.asia
aws.ec2.us-east-1--dp--https--gcp.gcs.asia-east1
aws.ec2.us-east-1--dp--https--gcp.gcs.asia-east2
aws.ec2.us-east-1--dp--https--gcp.gcs.asia-northeast1
aws.ec2.us-east-1--dp--https--gcp.gcs.asia-northeast2
aws.ec2.us-east-1--dp--https--gcp.gcs.asia-northeast3
aws.ec2.us-east-1--dp--https--gcp.gcs.asia-south1
aws.ec2.us-east-1--dp--https--gcp.gcs.asia-south2
aws.ec2.us-east-1--dp--https--gcp.gcs.asia-southeast1
aws.ec2.us-east-1--dp--https--gcp.gcs.asia-southeast2
aws.ec2.us-east-1--dp--https--gcp.gcs.australia-southeast1
aws.ec2.us-east-1--dp--https--gcp.gcs.australia-southeast2
aws.ec2.us-east-1--dp--https--gcp.gcs.eu
aws.ec2.us-east-1--dp--https--gcp.gcs.europe-central2
aws.ec2.us-east-1--dp--https--gcp.gcs.europe-north1
aws.ec2.us-east-1--dp--https--gcp.gcs.europe-southwest1
aws.ec2.us-east-1--dp--https--gcp.gcs.europe-west1
aws.ec2.us-east-1--dp--https--gcp.gcs.europe-west10
aws.ec2.us-east-1--dp--https--gcp.gcs.europe-west12
aws.ec2.us-east-1--dp--https--gcp.gcs.europe-west2
aws.ec2.us-east-1--dp--https--gcp.gcs.europe-west3
aws.ec2.us-east-1--dp--https--gcp.gcs.europe-west4
aws.ec2.us-east-1--dp--https--gcp.gcs.europe-west6
aws.ec2.us-east-1--dp--https--gcp.gcs.europe-west8
aws.ec2.us-east-1--dp--https--gcp.gcs.europe-west9
aws.ec2.us-east-1--dp--https--gcp.gcs.me-central1
aws.ec2.us-east-1--dp--https--gcp.gcs.me-west1
aws.ec2.us-east-1--dp--https--gcp.gcs.northamerica-northeast1
aws.ec2.us-east-1--dp--https--gcp.gcs.northamerica-northeast2
aws.ec2.us-east-1--dp--https--gcp.gcs.northamerica-south1
aws.ec2.us-east-1--dp--https--gcp.gcs.southamerica-east1
aws.ec2.us-east-1--dp--https--gcp.gcs.southamerica-west1
aws.ec2.us-east-1--dp--https--gcp.gcs.us
aws.ec2.us-east-1--dp--https--gcp.gcs.us-central1
aws.ec2.us-east-1--dp--https--gcp.gcs.us-east1
aws.ec2.us-east-1--dp--https--gcp.gcs.us-east4
aws.ec2.us-east-1--dp--https--gcp.gcs.us-east5
aws.ec2.us-east-1--dp--https--gcp.gcs.us-south1
aws.ec2.us-east-1--dp--https--gcp.gcs.us-west1
aws.ec2.us-east-1--dp--https--gcp.gcs.us-west2
aws.ec2.us-east-1--dp--https--gcp.gcs.us-west3
aws.ec2.us-east-1--dp--https--hetzner.cos.fsn1
aws.ec2.us-east-1--dp--https--hetzner.cos.hel1
aws.ec2.us-east-1--dp--https--hetzner.cos.nbg1
aws.ec2.us-east-1--dp--https--ibm.cos.ap-geo
aws.ec2.us-east-1--dp--https--ibm.cos.au-syd
aws.ec2.us-east-1--dp--https--ibm.cos.br-sao
aws.ec2.us-east-1--dp--https--ibm.cos.ca-tor
aws.ec2.us-east-1--dp--https--ibm.cos.eu-de
aws.ec2.us-east-1--dp--https--ibm.cos.eu-es
aws.ec2.us-east-1--dp--https--ibm.cos.eu-gb
aws.ec2.us-east-1--dp--https--ibm.cos.eu-geo
aws.ec2.us-east-1--dp--https--ibm.cos.jp-osa
aws.ec2.us-east-1--dp--https--ibm.cos.jp-tok
aws.ec2.us-east-1--dp--https--ibm.cos.us-east
aws.ec2.us-east-1--dp--https--ibm.cos.us-geo
aws.ec2.us-east-1--dp--https--ibm.cos.us-south
aws.ec2.us-east-1--dp--https--ionos.cos.de
aws.ec2.us-east-1--dp--https--ionos.cos.eu-central-2
aws.ec2.us-east-1--dp--https--ionos.cos.eu-central-3
aws.ec2.us-east-1--dp--https--ionos.cos.eu-south-2
aws.ec2.us-east-1--dp--https--ionos.cos.us-central-1
aws.ec2.us-east-1--dp--https--linode.storage.ap-south
aws.ec2.us-east-1--dp--https--linode.storage.au-mel
aws.ec2.us-east-1--dp--https--linode.storage.br-gru
aws.ec2.us-east-1--dp--https--linode.storage.es-mad
aws.ec2.us-east-1--dp--https--linode.storage.eu-central
aws.ec2.us-east-1--dp--https--linode.storage.fr-par
aws.ec2.us-east-1--dp--https--linode.storage.gb-lon
aws.ec2.us-east-1--dp--https--linode.storage.id-cgk
aws.ec2.us-east-1--dp--https--linode.storage.in-maa
aws.ec2.us-east-1--dp--https--linode.storage.it-mil
aws.ec2.us-east-1--dp--https--linode.storage.jp-osa
aws.ec2.us-east-1--dp--https--linode.storage.nl-ams
aws.ec2.us-east-1--dp--https--linode.storage.se-sto
aws.ec2.us-east-1--dp--https--linode.storage.sg-sin
aws.ec2.us-east-1--dp--https--linode.storage.us-east
aws.ec2.us-east-1--dp--https--linode.storage.us-iad
aws.ec2.us-east-1--dp--https--linode.storage.us-lax
aws.ec2.us-east-1--dp--https--linode.storage.us-mia
aws.ec2.us-east-1--dp--https--linode.storage.us-ord
aws.ec2.us-east-1--dp--https--linode.storage.us-sea
aws.ec2.us-east-1--dp--https--linode.storage.us-southeast
aws.ec2.us-east-1--dp--https--ovhcloud.cos.us-east-va
aws.ec2.us-east-1--dp--https--ovhcloud.cos.us-west-or
aws.ec2.us-east-1--dp--https--scaleway.cos.fr-par
aws.ec2.us-east-1--dp--https--scaleway.cos.nl-ams
aws.ec2.us-east-1--dp--https--scaleway.cos.pl-waw
aws.ec2.us-east-1--dp--https--tencent.cos.ap-bangkok
aws.ec2.us-east-1--dp--https--tencent.cos.ap-jakarta
aws.ec2.us-east-1--dp--https--tencent.cos.ap-seoul
aws.ec2.us-east-1--dp--https--tencent.cos.ap-singapore
aws.ec2.us-east-1--dp--https--tencent.cos.ap-tokyo
aws.ec2.us-east-1--dp--https--tencent.cos.eu-frankfurt
aws.ec2.us-east-1--dp--https--tencent.cos.na-ashburn
aws.ec2.us-east-1--dp--https--tencent.cos.na-siliconvalley
aws.ec2.us-east-1--dp--https--tencent.cos.sa-saopaulo
aws.ec2.us-east-1--dp--https--upcloud.cos.us-1
aws.ec2.us-east-1--dp--https--vultr.cos.sjc
aws.ec2.us-east-1--dp--httpsb-100mb--cloudflare.r2.eu
aws.ec2.us-east-1--dp--httpsb-100mb--cloudflare.r2.wnam
aws.ec2.us-east-1--dp--httpsb-100mb--digitalocean.spaces.ams3
aws.ec2.us-east-1--dp--httpsb-100mb--digitalocean.spaces.blr1
aws.ec2.us-east-1--dp--httpsb-100mb--digitalocean.spaces.fra1
aws.ec2.us-east-1--dp--httpsb-100mb--digitalocean.spaces.lon1
aws.ec2.us-east-1--dp--httpsb-100mb--digitalocean.spaces.nyc3
aws.ec2.us-east-1--dp--httpsb-100mb--digitalocean.spaces.sfo2
aws.ec2.us-east-1--dp--httpsb-100mb--digitalocean.spaces.sfo3
aws.ec2.us-east-1--dp--httpsb-100mb--digitalocean.spaces.sgp1
aws.ec2.us-east-1--dp--httpsb-100mb--digitalocean.spaces.syd1
aws.ec2.us-east-1--dp--httpsb-100mb--digitalocean.spaces.tor1
aws.ec2.us-east-1--dp--httpsb-100mb--hetzner.cos.fsn1
aws.ec2.us-east-1--dp--httpsb-100mb--hetzner.cos.hel1
aws.ec2.us-east-1--dp--httpsb-100mb--hetzner.cos.nbg1
aws.ec2.us-east-1--dp--httpsb-100mb--ovhcloud.cos.us-east-va
aws.ec2.us-east-1--dp--httpsb-100mb--ovhcloud.cos.us-west-or
aws.ec2.us-east-1--dp--httpsb-100mb--vultr.cos.sjc
aws.ec2.us-east-1--dp--tcping4--alibaba.oss.ap-northeast-1
aws.ec2.us-east-1--dp--tcping4--alibaba.oss.ap-northeast-2
aws.ec2.us-east-1--dp--tcping4--alibaba.oss.ap-southeast-1
aws.ec2.us-east-1--dp--tcping4--alibaba.oss.ap-southeast-3
aws.ec2.us-east-1--dp--tcping4--alibaba.oss.ap-southeast-5
aws.ec2.us-east-1--dp--tcping4--alibaba.oss.ap-southeast-6
aws.ec2.us-east-1--dp--tcping4--alibaba.oss.ap-southeast-7
aws.ec2.us-east-1--dp--tcping4--alibaba.oss.eu-central-1
aws.ec2.us-east-1--dp--tcping4--alibaba.oss.eu-west-1
aws.ec2.us-east-1--dp--tcping4--alibaba.oss.me-central-1
aws.ec2.us-east-1--dp--tcping4--alibaba.oss.me-east-1
aws.ec2.us-east-1--dp--tcping4--alibaba.oss.na-south-1
aws.ec2.us-east-1--dp--tcping4--alibaba.oss.us-east-1
aws.ec2.us-east-1--dp--tcping4--alibaba.oss.us-west-1
aws.ec2.us-east-1--dp--tcping4--apac.central-asia
aws.ec2.us-east-1--dp--tcping4--apac.east-asia
aws.ec2.us-east-1--dp--tcping4--apac.oceania
aws.ec2.us-east-1--dp--tcping4--apac.south-asia
aws.ec2.us-east-1--dp--tcping4--apac.southeast-asia
aws.ec2.us-east-1--dp--tcping4--azure.storage.australiacentral
aws.ec2.us-east-1--dp--tcping4--azure.storage.australiaeast
aws.ec2.us-east-1--dp--tcping4--azure.storage.australiasoutheast
aws.ec2.us-east-1--dp--tcping4--azure.storage.brazilsouth
aws.ec2.us-east-1--dp--tcping4--azure.storage.canadacentral
aws.ec2.us-east-1--dp--tcping4--azure.storage.canadaeast
aws.ec2.us-east-1--dp--tcping4--azure.storage.centralindia
aws.ec2.us-east-1--dp--tcping4--azure.storage.centralus
aws.ec2.us-east-1--dp--tcping4--azure.storage.eastasia
aws.ec2.us-east-1--dp--tcping4--azure.storage.eastus
aws.ec2.us-east-1--dp--tcping4--azure.storage.eastus2
aws.ec2.us-east-1--dp--tcping4--azure.storage.francecentral
aws.ec2.us-east-1--dp--tcping4--azure.storage.germanywestcentral
aws.ec2.us-east-1--dp--tcping4--azure.storage.israelcentral
aws.ec2.us-east-1--dp--tcping4--azure.storage.italynorth
aws.ec2.us-east-1--dp--tcping4--azure.storage.japaneast
aws.ec2.us-east-1--dp--tcping4--azure.storage.japanwest
aws.ec2.us-east-1--dp--tcping4--azure.storage.koreacentral
aws.ec2.us-east-1--dp--tcping4--azure.storage.koreasouth
aws.ec2.us-east-1--dp--tcping4--azure.storage.mexicocentral
aws.ec2.us-east-1--dp--tcping4--azure.storage.newzealandnorth
aws.ec2.us-east-1--dp--tcping4--azure.storage.northcentralus
aws.ec2.us-east-1--dp--tcping4--azure.storage.northeurope
aws.ec2.us-east-1--dp--tcping4--azure.storage.norwayeast
aws.ec2.us-east-1--dp--tcping4--azure.storage.polandcentral
aws.ec2.us-east-1--dp--tcping4--azure.storage.qatarcentral
aws.ec2.us-east-1--dp--tcping4--azure.storage.southafricanorth
aws.ec2.us-east-1--dp--tcping4--azure.storage.southcentralus
aws.ec2.us-east-1--dp--tcping4--azure.storage.southeastasia
aws.ec2.us-east-1--dp--tcping4--azure.storage.southindia
aws.ec2.us-east-1--dp--tcping4--azure.storage.spaincentral
aws.ec2.us-east-1--dp--tcping4--azure.storage.swedencentral
aws.ec2.us-east-1--dp--tcping4--azure.storage.switzerlandnorth
aws.ec2.us-east-1--dp--tcping4--azure.storage.uaenorth
aws.ec2.us-east-1--dp--tcping4--azure.storage.uksouth
aws.ec2.us-east-1--dp--tcping4--azure.storage.ukwest
aws.ec2.us-east-1--dp--tcping4--azure.storage.westcentralus
aws.ec2.us-east-1--dp--tcping4--azure.storage.westeurope
aws.ec2.us-east-1--dp--tcping4--azure.storage.westindia
aws.ec2.us-east-1--dp--tcping4--azure.storage.westus
aws.ec2.us-east-1--dp--tcping4--azure.storage.westus2
aws.ec2.us-east-1--dp--tcping4--azure.storage.westus3
aws.ec2.us-east-1--dp--tcping4--cloudflare.r2.eu
aws.ec2.us-east-1--dp--tcping4--cloudflare.r2.wnam
aws.ec2.us-east-1--dp--tcping4--digitalocean.spaces.ams3
aws.ec2.us-east-1--dp--tcping4--digitalocean.spaces.blr1
aws.ec2.us-east-1--dp--tcping4--digitalocean.spaces.fra1
aws.ec2.us-east-1--dp--tcping4--digitalocean.spaces.lon1
aws.ec2.us-east-1--dp--tcping4--digitalocean.spaces.nyc3
aws.ec2.us-east-1--dp--tcping4--digitalocean.spaces.sfo2
aws.ec2.us-east-1--dp--tcping4--digitalocean.spaces.sfo3
aws.ec2.us-east-1--dp--tcping4--digitalocean.spaces.sgp1
aws.ec2.us-east-1--dp--tcping4--digitalocean.spaces.syd1
aws.ec2.us-east-1--dp--tcping4--digitalocean.spaces.tor1
aws.ec2.us-east-1--dp--tcping4--eu.eu-central
aws.ec2.us-east-1--dp--tcping4--eu.eu-east
aws.ec2.us-east-1--dp--tcping4--eu.eu-north
aws.ec2.us-east-1--dp--tcping4--eu.eu-south
aws.ec2.us-east-1--dp--tcping4--eu.eu-west
aws.ec2.us-east-1--dp--tcping4--hetzner.cos.fsn1
aws.ec2.us-east-1--dp--tcping4--hetzner.cos.hel1
aws.ec2.us-east-1--dp--tcping4--hetzner.cos.nbg1
aws.ec2.us-east-1--dp--tcping4--ibm.cos.ap-geo
aws.ec2.us-east-1--dp--tcping4--ibm.cos.au-syd
aws.ec2.us-east-1--dp--tcping4--ibm.cos.br-sao
aws.ec2.us-east-1--dp--tcping4--ibm.cos.ca-tor
aws.ec2.us-east-1--dp--tcping4--ibm.cos.eu-de
aws.ec2.us-east-1--dp--tcping4--ibm.cos.eu-es
aws.ec2.us-east-1--dp--tcping4--ibm.cos.eu-gb
aws.ec2.us-east-1--dp--tcping4--ibm.cos.eu-geo
aws.ec2.us-east-1--dp--tcping4--ibm.cos.jp-osa
aws.ec2.us-east-1--dp--tcping4--ibm.cos.jp-tok
aws.ec2.us-east-1--dp--tcping4--ibm.cos.us-east
aws.ec2.us-east-1--dp--tcping4--ibm.cos.us-geo
aws.ec2.us-east-1--dp--tcping4--ibm.cos.us-south
aws.ec2.us-east-1--dp--tcping4--ionos.cos.de
aws.ec2.us-east-1--dp--tcping4--ionos.cos.eu-central-2
aws.ec2.us-east-1--dp--tcping4--ionos.cos.eu-central-3
aws.ec2.us-east-1--dp--tcping4--ionos.cos.eu-south-2
aws.ec2.us-east-1--dp--tcping4--ionos.cos.us-central-1
aws.ec2.us-east-1--dp--tcping4--linode.storage.ap-south
aws.ec2.us-east-1--dp--tcping4--linode.storage.au-mel
aws.ec2.us-east-1--dp--tcping4--linode.storage.br-gru
aws.ec2.us-east-1--dp--tcping4--linode.storage.es-mad
aws.ec2.us-east-1--dp--tcping4--linode.storage.eu-central
aws.ec2.us-east-1--dp--tcping4--linode.storage.fr-par
aws.ec2.us-east-1--dp--tcping4--linode.storage.gb-lon
aws.ec2.us-east-1--dp--tcping4--linode.storage.id-cgk
aws.ec2.us-east-1--dp--tcping4--linode.storage.in-maa
aws.ec2.us-east-1--dp--tcping4--linode.storage.it-mil
aws.ec2.us-east-1--dp--tcping4--linode.storage.jp-osa
aws.ec2.us-east-1--dp--tcping4--linode.storage.nl-ams
aws.ec2.us-east-1--dp--tcping4--linode.storage.se-sto
aws.ec2.us-east-1--dp--tcping4--linode.storage.sg-sin
aws.ec2.us-east-1--dp--tcping4--linode.storage.us-east
aws.ec2.us-east-1--dp--tcping4--linode.storage.us-iad
aws.ec2.us-east-1--dp--tcping4--linode.storage.us-lax
aws.ec2.us-east-1--dp--tcping4--linode.storage.us-mia
aws.ec2.us-east-1--dp--tcping4--linode.storage.us-ord
aws.ec2.us-east-1--dp--tcping4--linode.storage.us-sea
aws.ec2.us-east-1--dp--tcping4--linode.storage.us-southeast
aws.ec2.us-east-1--dp--tcping4--mea.middle-east
aws.ec2.us-east-1--dp--tcping4--mea.north-africa
aws.ec2.us-east-1--dp--tcping4--mea.sub-saharan-africa
aws.ec2.us-east-1--dp--tcping4--north-america.us-midwest
aws.ec2.us-east-1--dp--tcping4--north-america.us-mountain
aws.ec2.us-east-1--dp--tcping4--north-america.us-northeast
aws.ec2.us-east-1--dp--tcping4--north-america.us-pnw
aws.ec2.us-east-1--dp--tcping4--north-america.us-southeast
aws.ec2.us-east-1--dp--tcping4--north-america.us-southwest
aws.ec2.us-east-1--dp--tcping4--oci.oss.af-johannesburg-1
aws.ec2.us-east-1--dp--tcping4--oci.oss.ap-chuncheon-1
aws.ec2.us-east-1--dp--tcping4--oci.oss.ap-hyderabad-1
aws.ec2.us-east-1--dp--tcping4--oci.oss.ap-melbourne-1
aws.ec2.us-east-1--dp--tcping4--oci.oss.ap-mumbai-1
aws.ec2.us-east-1--dp--tcping4--oci.oss.ap-osaka-1
aws.ec2.us-east-1--dp--tcping4--oci.oss.ap-seoul-1
aws.ec2.us-east-1--dp--tcping4--oci.oss.ap-singapore-1
aws.ec2.us-east-1--dp--tcping4--oci.oss.ap-singapore-2
aws.ec2.us-east-1--dp--tcping4--oci.oss.ap-sydney-1
aws.ec2.us-east-1--dp--tcping4--oci.oss.ap-tokyo-1
aws.ec2.us-east-1--dp--tcping4--oci.oss.ca-montreal-1
aws.ec2.us-east-1--dp--tcping4--oci.oss.ca-toronto-1
aws.ec2.us-east-1--dp--tcping4--oci.oss.eu-amsterdam-1
aws.ec2.us-east-1--dp--tcping4--oci.oss.eu-frankfurt-1
aws.ec2.us-east-1--dp--tcping4--oci.oss.eu-madrid-1
aws.ec2.us-east-1--dp--tcping4--oci.oss.eu-marseille-1
aws.ec2.us-east-1--dp--tcping4--oci.oss.eu-milan-1
aws.ec2.us-east-1--dp--tcping4--oci.oss.eu-paris-1
aws.ec2.us-east-1--dp--tcping4--oci.oss.eu-stockholm-1
aws.ec2.us-east-1--dp--tcping4--oci.oss.eu-zurich-1
aws.ec2.us-east-1--dp--tcping4--oci.oss.il-jerusalem-1
aws.ec2.us-east-1--dp--tcping4--oci.oss.me-abudhabi-1
aws.ec2.us-east-1--dp--tcping4--oci.oss.me-dubai-1
aws.ec2.us-east-1--dp--tcping4--oci.oss.me-jeddah-1
aws.ec2.us-east-1--dp--tcping4--oci.oss.me-riyadh-1
aws.ec2.us-east-1--dp--tcping4--oci.oss.mx-monterrey-1
aws.ec2.us-east-1--dp--tcping4--oci.oss.mx-queretaro-1
aws.ec2.us-east-1--dp--tcping4--oci.oss.sa-bogota-1
aws.ec2.us-east-1--dp--tcping4--oci.oss.sa-santiago-1
aws.ec2.us-east-1--dp--tcping4--oci.oss.sa-saopaulo-1
aws.ec2.us-east-1--dp--tcping4--oci.oss.sa-valparaiso-1
aws.ec2.us-east-1--dp--tcping4--oci.oss.sa-vinhedo-1
aws.ec2.us-east-1--dp--tcping4--oci.oss.uk-cardiff-1
aws.ec2.us-east-1--dp--tcping4--oci.oss.uk-london-1
aws.ec2.us-east-1--dp--tcping4--oci.oss.us-ashburn-1
aws.ec2.us-east-1--dp--tcping4--oci.oss.us-chicago-1
aws.ec2.us-east-1--dp--tcping4--oci.oss.us-phoenix-1
aws.ec2.us-east-1--dp--tcping4--oci.oss.us-sanjose-1
aws.ec2.us-east-1--dp--tcping4--ovhcloud.cos.us-east-va
aws.ec2.us-east-1--dp--tcping4--ovhcloud.cos.us-west-or
aws.ec2.us-east-1--dp--tcping4--scaleway.cos.fr-par
aws.ec2.us-east-1--dp--tcping4--scaleway.cos.nl-ams
aws.ec2.us-east-1--dp--tcping4--scaleway.cos.pl-waw
aws.ec2.us-east-1--dp--tcping4--tencent.cos.ap-bangkok
aws.ec2.us-east-1--dp--tcping4--tencent.cos.ap-jakarta
aws.ec2.us-east-1--dp--tcping4--tencent.cos.ap-seoul
aws.ec2.us-east-1--dp--tcping4--tencent.cos.ap-singapore
aws.ec2.us-east-1--dp--tcping4--tencent.cos.ap-tokyo
aws.ec2.us-east-1--dp--tcping4--tencent.cos.eu-frankfurt
aws.ec2.us-east-1--dp--tcping4--tencent.cos.na-ashburn
aws.ec2.us-east-1--dp--tcping4--tencent.cos.na-siliconvalley
aws.ec2.us-east-1--dp--tcping4--tencent.cos.sa-saopaulo
aws.ec2.us-east-1--dp--tcping4--upcloud.cos.us-1
aws.ec2.us-east-1--dp--tcping4--vultr.cos.sjc
aws.ec2.us-east-1--dp--tcping6--apac.central-asia
aws.ec2.us-east-1--dp--tcping6--apac.east-asia
aws.ec2.us-east-1--dp--tcping6--apac.oceania
aws.ec2.us-east-1--dp--tcping6--apac.south-asia
aws.ec2.us-east-1--dp--tcping6--apac.southeast-asia
aws.ec2.us-east-1--dp--tcping6--cloudflare.r2.eu
aws.ec2.us-east-1--dp--tcping6--cloudflare.r2.wnam
aws.ec2.us-east-1--dp--tcping6--eu.eu-central
aws.ec2.us-east-1--dp--tcping6--eu.eu-east
aws.ec2.us-east-1--dp--tcping6--eu.eu-north
aws.ec2.us-east-1--dp--tcping6--eu.eu-south
aws.ec2.us-east-1--dp--tcping6--eu.eu-west
aws.ec2.us-east-1--dp--tcping6--hetzner.cos.fsn1
aws.ec2.us-east-1--dp--tcping6--hetzner.cos.hel1
aws.ec2.us-east-1--dp--tcping6--hetzner.cos.nbg1
aws.ec2.us-east-1--dp--tcping6--linode.storage.ap-south
aws.ec2.us-east-1--dp--tcping6--linode.storage.au-mel
aws.ec2.us-east-1--dp--tcping6--linode.storage.br-gru
aws.ec2.us-east-1--dp--tcping6--linode.storage.es-mad
aws.ec2.us-east-1--dp--tcping6--linode.storage.eu-central
aws.ec2.us-east-1--dp--tcping6--linode.storage.fr-par
aws.ec2.us-east-1--dp--tcping6--linode.storage.gb-lon
aws.ec2.us-east-1--dp--tcping6--linode.storage.id-cgk
aws.ec2.us-east-1--dp--tcping6--linode.storage.in-maa
aws.ec2.us-east-1--dp--tcping6--linode.storage.it-mil
aws.ec2.us-east-1--dp--tcping6--linode.storage.jp-osa
aws.ec2.us-east-1--dp--tcping6--linode.storage.nl-ams
aws.ec2.us-east-1--dp--tcping6--linode.storage.se-sto
aws.ec2.us-east-1--dp--tcping6--linode.storage.sg-sin
aws.ec2.us-east-1--dp--tcping6--linode.storage.us-east
aws.ec2.us-east-1--dp--tcping6--linode.storage.us-iad
aws.ec2.us-east-1--dp--tcping6--linode.storage.us-lax
aws.ec2.us-east-1--dp--tcping6--linode.storage.us-mia
aws.ec2.us-east-1--dp--tcping6--linode.storage.us-ord
aws.ec2.us-east-1--dp--tcping6--linode.storage.us-sea
aws.ec2.us-east-1--dp--tcping6--linode.storage.us-southeast
aws.ec2.us-east-1--dp--tcping6--mea.middle-east
aws.ec2.us-east-1--dp--tcping6--mea.north-africa
aws.ec2.us-east-1--dp--tcping6--mea.sub-saharan-africa
aws.ec2.us-east-1--dp--tcping6--north-america.us-midwest
aws.ec2.us-east-1--dp--tcping6--north-america.us-mountain
aws.ec2.us-east-1--dp--tcping6--north-america.us-northeast
aws.ec2.us-east-1--dp--tcping6--north-america.us-pnw
aws.ec2.us-east-1--dp--tcping6--north-america.us-southeast
aws.ec2.us-east-1--dp--tcping6--north-america.us-southwest
aws.ec2.us-east-1--dp--tcping6--scaleway.cos.fr-par
aws.ec2.us-east-1--dp--tcping6--scaleway.cos.nl-ams
aws.ec2.us-east-1--dp--tcping6--scaleway.cos.pl-waw
aws.ec2.us-east-1--dp--tcping6--vultr.cos.sjc
gcp.us-central1--dp--gping4--aws.ca-central-1
gcp.us-central1--dp--gping4--aws.us-east-1
gcp.us-central1--dp--gping4--aws.us-east-2
gcp.us-central1--dp--gping4--aws.us-west-1
gcp.us-central1--dp--gping4--aws.us-west-2
Tests from cloud providers to geographic endpoints (countries, continents, US states) and tests from geographic probe networks (RIPE Atlas, Globalping) to cloud services. Includes tests from regions like EU, APAC, MEA, Americas, etc.
apac--dp--adns--akamai.dns
apac--dp--adns--alibaba.dns
apac--dp--adns--aws.route53
apac--dp--adns--azure.dns
apac--dp--adns--bunny.dns
apac--dp--adns--cloudflare.dns
apac--dp--adns--digitalocean.dns
apac--dp--adns--dnsmadeeasy.dns
apac--dp--adns--easydns.dns
apac--dp--adns--gcp.dns
apac--dp--adns--ns1.dns
apac--dp--adns--rage4.dns
apac--dp--adns--ultradns.dns
apac--dp--aping4--akamai.cdn
apac--dp--aping4--alibaba.cdn
apac--dp--aping4--aws.cloudfront
apac--dp--aping4--bunny.cdn
apac--dp--aping4--cachefly.cdn
apac--dp--aping4--cloudflare.cdn
apac--dp--aping4--digitalocean.cdn
apac--dp--aping4--fastly.cdn
apac--dp--aping4--gcp.cdn
apac--dp--aping4--scaleway.cdn
apac--dp--aping4--tencent.cdn
apac--dp--gping4--akamai.cdn
apac--dp--gping4--alibaba.cdn
apac--dp--gping4--aws.cloudfront
apac--dp--gping4--bunny.cdn
apac--dp--gping4--cachefly.cdn
apac--dp--gping4--cdnetworks.cdn
apac--dp--gping4--cloudflare.cdn
apac--dp--gping4--digitalocean.cdn
apac--dp--gping4--fastly.cdn
apac--dp--gping4--gcp.cdn
apac--dp--gping4--scaleway.cdn
apac--dp--gping4--tencent.cdn
aws.ec2.us-east-1--dp--tcping4--ad
aws.ec2.us-east-1--dp--tcping4--ae
aws.ec2.us-east-1--dp--tcping4--af
aws.ec2.us-east-1--dp--tcping4--ag
aws.ec2.us-east-1--dp--tcping4--ai
aws.ec2.us-east-1--dp--tcping4--al
aws.ec2.us-east-1--dp--tcping4--am
aws.ec2.us-east-1--dp--tcping4--ao
aws.ec2.us-east-1--dp--tcping4--apac
aws.ec2.us-east-1--dp--tcping4--ar
aws.ec2.us-east-1--dp--tcping4--at
aws.ec2.us-east-1--dp--tcping4--au
aws.ec2.us-east-1--dp--tcping4--aw
aws.ec2.us-east-1--dp--tcping4--az
aws.ec2.us-east-1--dp--tcping4--ba
aws.ec2.us-east-1--dp--tcping4--bb
aws.ec2.us-east-1--dp--tcping4--bd
aws.ec2.us-east-1--dp--tcping4--be
aws.ec2.us-east-1--dp--tcping4--bf
aws.ec2.us-east-1--dp--tcping4--bg
aws.ec2.us-east-1--dp--tcping4--bh
aws.ec2.us-east-1--dp--tcping4--bi
aws.ec2.us-east-1--dp--tcping4--bj
aws.ec2.us-east-1--dp--tcping4--bm
aws.ec2.us-east-1--dp--tcping4--bn
aws.ec2.us-east-1--dp--tcping4--bo
aws.ec2.us-east-1--dp--tcping4--bq
aws.ec2.us-east-1--dp--tcping4--br
aws.ec2.us-east-1--dp--tcping4--bs
aws.ec2.us-east-1--dp--tcping4--bt
aws.ec2.us-east-1--dp--tcping4--bw
aws.ec2.us-east-1--dp--tcping4--by
aws.ec2.us-east-1--dp--tcping4--bz
aws.ec2.us-east-1--dp--tcping4--ca
aws.ec2.us-east-1--dp--tcping4--cd
aws.ec2.us-east-1--dp--tcping4--central-america
aws.ec2.us-east-1--dp--tcping4--cg
aws.ec2.us-east-1--dp--tcping4--ch
aws.ec2.us-east-1--dp--tcping4--ci
aws.ec2.us-east-1--dp--tcping4--cl
aws.ec2.us-east-1--dp--tcping4--co
aws.ec2.us-east-1--dp--tcping4--cr
aws.ec2.us-east-1--dp--tcping4--cw
aws.ec2.us-east-1--dp--tcping4--cy
aws.ec2.us-east-1--dp--tcping4--cz
aws.ec2.us-east-1--dp--tcping4--de
aws.ec2.us-east-1--dp--tcping4--dj
aws.ec2.us-east-1--dp--tcping4--dk
aws.ec2.us-east-1--dp--tcping4--do
aws.ec2.us-east-1--dp--tcping4--dz
aws.ec2.us-east-1--dp--tcping4--ec
aws.ec2.us-east-1--dp--tcping4--ee
aws.ec2.us-east-1--dp--tcping4--eg
aws.ec2.us-east-1--dp--tcping4--es
aws.ec2.us-east-1--dp--tcping4--et
aws.ec2.us-east-1--dp--tcping4--eu
aws.ec2.us-east-1--dp--tcping4--fi
aws.ec2.us-east-1--dp--tcping4--fj
aws.ec2.us-east-1--dp--tcping4--fo
aws.ec2.us-east-1--dp--tcping4--fr
aws.ec2.us-east-1--dp--tcping4--ga
aws.ec2.us-east-1--dp--tcping4--gb
aws.ec2.us-east-1--dp--tcping4--gd
aws.ec2.us-east-1--dp--tcping4--ge
aws.ec2.us-east-1--dp--tcping4--gf
aws.ec2.us-east-1--dp--tcping4--gh
aws.ec2.us-east-1--dp--tcping4--gi
aws.ec2.us-east-1--dp--tcping4--gl
aws.ec2.us-east-1--dp--tcping4--gm
aws.ec2.us-east-1--dp--tcping4--gn
aws.ec2.us-east-1--dp--tcping4--gr
aws.ec2.us-east-1--dp--tcping4--gt
aws.ec2.us-east-1--dp--tcping4--gu
aws.ec2.us-east-1--dp--tcping4--gy
aws.ec2.us-east-1--dp--tcping4--hk
aws.ec2.us-east-1--dp--tcping4--hn
aws.ec2.us-east-1--dp--tcping4--hr
aws.ec2.us-east-1--dp--tcping4--hu
aws.ec2.us-east-1--dp--tcping4--id
aws.ec2.us-east-1--dp--tcping4--ie
aws.ec2.us-east-1--dp--tcping4--il
aws.ec2.us-east-1--dp--tcping4--im
aws.ec2.us-east-1--dp--tcping4--in
aws.ec2.us-east-1--dp--tcping4--iq
aws.ec2.us-east-1--dp--tcping4--ir
aws.ec2.us-east-1--dp--tcping4--is
aws.ec2.us-east-1--dp--tcping4--it
aws.ec2.us-east-1--dp--tcping4--je
aws.ec2.us-east-1--dp--tcping4--jm
aws.ec2.us-east-1--dp--tcping4--jo
aws.ec2.us-east-1--dp--tcping4--jp
aws.ec2.us-east-1--dp--tcping4--ke
aws.ec2.us-east-1--dp--tcping4--kg
aws.ec2.us-east-1--dp--tcping4--kh
aws.ec2.us-east-1--dp--tcping4--ki
aws.ec2.us-east-1--dp--tcping4--kn
aws.ec2.us-east-1--dp--tcping4--kw
aws.ec2.us-east-1--dp--tcping4--ky
aws.ec2.us-east-1--dp--tcping4--kz
aws.ec2.us-east-1--dp--tcping4--la
aws.ec2.us-east-1--dp--tcping4--lb
aws.ec2.us-east-1--dp--tcping4--li
aws.ec2.us-east-1--dp--tcping4--lk
aws.ec2.us-east-1--dp--tcping4--lr
aws.ec2.us-east-1--dp--tcping4--lt
aws.ec2.us-east-1--dp--tcping4--lu
aws.ec2.us-east-1--dp--tcping4--lv
aws.ec2.us-east-1--dp--tcping4--ly
aws.ec2.us-east-1--dp--tcping4--ma
aws.ec2.us-east-1--dp--tcping4--mc
aws.ec2.us-east-1--dp--tcping4--md
aws.ec2.us-east-1--dp--tcping4--me
aws.ec2.us-east-1--dp--tcping4--mea
aws.ec2.us-east-1--dp--tcping4--mg
aws.ec2.us-east-1--dp--tcping4--mh
aws.ec2.us-east-1--dp--tcping4--mk
aws.ec2.us-east-1--dp--tcping4--ml
aws.ec2.us-east-1--dp--tcping4--mm
aws.ec2.us-east-1--dp--tcping4--mn
aws.ec2.us-east-1--dp--tcping4--mo
aws.ec2.us-east-1--dp--tcping4--mq
aws.ec2.us-east-1--dp--tcping4--mt
aws.ec2.us-east-1--dp--tcping4--mu
aws.ec2.us-east-1--dp--tcping4--mv
aws.ec2.us-east-1--dp--tcping4--mw
aws.ec2.us-east-1--dp--tcping4--mx
aws.ec2.us-east-1--dp--tcping4--my
aws.ec2.us-east-1--dp--tcping4--mz
aws.ec2.us-east-1--dp--tcping4--na
aws.ec2.us-east-1--dp--tcping4--nc
aws.ec2.us-east-1--dp--tcping4--ne
aws.ec2.us-east-1--dp--tcping4--ng
aws.ec2.us-east-1--dp--tcping4--nl
aws.ec2.us-east-1--dp--tcping4--no
aws.ec2.us-east-1--dp--tcping4--north-america
aws.ec2.us-east-1--dp--tcping4--np
aws.ec2.us-east-1--dp--tcping4--nz
aws.ec2.us-east-1--dp--tcping4--om
aws.ec2.us-east-1--dp--tcping4--pa
aws.ec2.us-east-1--dp--tcping4--pe
aws.ec2.us-east-1--dp--tcping4--pg
aws.ec2.us-east-1--dp--tcping4--ph
aws.ec2.us-east-1--dp--tcping4--pk
aws.ec2.us-east-1--dp--tcping4--pl
aws.ec2.us-east-1--dp--tcping4--pr
aws.ec2.us-east-1--dp--tcping4--ps
aws.ec2.us-east-1--dp--tcping4--pt
aws.ec2.us-east-1--dp--tcping4--pw
aws.ec2.us-east-1--dp--tcping4--py
aws.ec2.us-east-1--dp--tcping4--qa
aws.ec2.us-east-1--dp--tcping4--ro
aws.ec2.us-east-1--dp--tcping4--rs
aws.ec2.us-east-1--dp--tcping4--ru
aws.ec2.us-east-1--dp--tcping4--rw
aws.ec2.us-east-1--dp--tcping4--sa
aws.ec2.us-east-1--dp--tcping4--sb
aws.ec2.us-east-1--dp--tcping4--sc
aws.ec2.us-east-1--dp--tcping4--sd
aws.ec2.us-east-1--dp--tcping4--se
aws.ec2.us-east-1--dp--tcping4--sg
aws.ec2.us-east-1--dp--tcping4--si
aws.ec2.us-east-1--dp--tcping4--sk
aws.ec2.us-east-1--dp--tcping4--sl
aws.ec2.us-east-1--dp--tcping4--sn
aws.ec2.us-east-1--dp--tcping4--so
aws.ec2.us-east-1--dp--tcping4--south-america
aws.ec2.us-east-1--dp--tcping4--sr
aws.ec2.us-east-1--dp--tcping4--ss
aws.ec2.us-east-1--dp--tcping4--sv
aws.ec2.us-east-1--dp--tcping4--sx
aws.ec2.us-east-1--dp--tcping4--sz
aws.ec2.us-east-1--dp--tcping4--tc
aws.ec2.us-east-1--dp--tcping4--tg
aws.ec2.us-east-1--dp--tcping4--th
aws.ec2.us-east-1--dp--tcping4--tj
aws.ec2.us-east-1--dp--tcping4--tl
aws.ec2.us-east-1--dp--tcping4--tn
aws.ec2.us-east-1--dp--tcping4--tr
aws.ec2.us-east-1--dp--tcping4--tt
aws.ec2.us-east-1--dp--tcping4--tw
aws.ec2.us-east-1--dp--tcping4--tz
aws.ec2.us-east-1--dp--tcping4--ua
aws.ec2.us-east-1--dp--tcping4--ug
aws.ec2.us-east-1--dp--tcping4--us.ak
aws.ec2.us-east-1--dp--tcping4--us.al
aws.ec2.us-east-1--dp--tcping4--us.ar
aws.ec2.us-east-1--dp--tcping4--us.az
aws.ec2.us-east-1--dp--tcping4--us.ca
aws.ec2.us-east-1--dp--tcping4--us.co
aws.ec2.us-east-1--dp--tcping4--us.ct
aws.ec2.us-east-1--dp--tcping4--us.de
aws.ec2.us-east-1--dp--tcping4--us.fl
aws.ec2.us-east-1--dp--tcping4--us.ga
aws.ec2.us-east-1--dp--tcping4--us.hi
aws.ec2.us-east-1--dp--tcping4--us.ia
aws.ec2.us-east-1--dp--tcping4--us.id
aws.ec2.us-east-1--dp--tcping4--us.il
aws.ec2.us-east-1--dp--tcping4--us.in
aws.ec2.us-east-1--dp--tcping4--us.ks
aws.ec2.us-east-1--dp--tcping4--us.ky
aws.ec2.us-east-1--dp--tcping4--us.la
aws.ec2.us-east-1--dp--tcping4--us.ma
aws.ec2.us-east-1--dp--tcping4--us.md
aws.ec2.us-east-1--dp--tcping4--us.me
aws.ec2.us-east-1--dp--tcping4--us.mi
aws.ec2.us-east-1--dp--tcping4--us.mn
aws.ec2.us-east-1--dp--tcping4--us.mo
aws.ec2.us-east-1--dp--tcping4--us.ms
aws.ec2.us-east-1--dp--tcping4--us.mt
aws.ec2.us-east-1--dp--tcping4--us.nc
aws.ec2.us-east-1--dp--tcping4--us.nd
aws.ec2.us-east-1--dp--tcping4--us.ne
aws.ec2.us-east-1--dp--tcping4--us.nh
aws.ec2.us-east-1--dp--tcping4--us.nj
aws.ec2.us-east-1--dp--tcping4--us.nm
aws.ec2.us-east-1--dp--tcping4--us.nv
aws.ec2.us-east-1--dp--tcping4--us.ny
aws.ec2.us-east-1--dp--tcping4--us.oh
aws.ec2.us-east-1--dp--tcping4--us.ok
aws.ec2.us-east-1--dp--tcping4--us.or
aws.ec2.us-east-1--dp--tcping4--us.pa
aws.ec2.us-east-1--dp--tcping4--us.ri
aws.ec2.us-east-1--dp--tcping4--us.sc
aws.ec2.us-east-1--dp--tcping4--us.sd
aws.ec2.us-east-1--dp--tcping4--us.tn
aws.ec2.us-east-1--dp--tcping4--us.tx
aws.ec2.us-east-1--dp--tcping4--us.ut
aws.ec2.us-east-1--dp--tcping4--us.va
aws.ec2.us-east-1--dp--tcping4--us.vt
aws.ec2.us-east-1--dp--tcping4--us.wa
aws.ec2.us-east-1--dp--tcping4--us.wi
aws.ec2.us-east-1--dp--tcping4--us.wv
aws.ec2.us-east-1--dp--tcping4--us.wy
aws.ec2.us-east-1--dp--tcping4--uy
aws.ec2.us-east-1--dp--tcping4--uz
aws.ec2.us-east-1--dp--tcping4--ve
aws.ec2.us-east-1--dp--tcping4--vg
aws.ec2.us-east-1--dp--tcping4--vi
aws.ec2.us-east-1--dp--tcping4--vn
aws.ec2.us-east-1--dp--tcping4--ws
aws.ec2.us-east-1--dp--tcping4--xk
aws.ec2.us-east-1--dp--tcping4--za
aws.ec2.us-east-1--dp--tcping4--zm
aws.ec2.us-east-1--dp--tcping4--zw
aws.ec2.us-east-1--dp--tcping6--apac
aws.ec2.us-east-1--dp--tcping6--central-america
aws.ec2.us-east-1--dp--tcping6--eu
aws.ec2.us-east-1--dp--tcping6--mea
aws.ec2.us-east-1--dp--tcping6--north-america
aws.ec2.us-east-1--dp--tcping6--south-america
central-america--dp--adns--akamai.dns
central-america--dp--adns--alibaba.dns
central-america--dp--adns--aws.route53
central-america--dp--adns--azure.dns
central-america--dp--adns--bunny.dns
central-america--dp--adns--cloudflare.dns
central-america--dp--adns--digitalocean.dns
central-america--dp--adns--dnsmadeeasy.dns
central-america--dp--adns--easydns.dns
central-america--dp--adns--gcp.dns
central-america--dp--adns--ns1.dns
central-america--dp--adns--rage4.dns
central-america--dp--adns--ultradns.dns
central-america--dp--aping4--akamai.cdn
central-america--dp--aping4--alibaba.cdn
central-america--dp--aping4--aws.cloudfront
central-america--dp--aping4--bunny.cdn
central-america--dp--aping4--cachefly.cdn
central-america--dp--aping4--cdnetworks.cdn
central-america--dp--aping4--cloudflare.cdn
central-america--dp--aping4--digitalocean.cdn
central-america--dp--aping4--fastly.cdn
central-america--dp--aping4--gcp.cdn
central-america--dp--aping4--scaleway.cdn
central-america--dp--aping4--tencent.cdn
central-america--dp--gping4--akamai.cdn
central-america--dp--gping4--alibaba.cdn
central-america--dp--gping4--aws.cloudfront
central-america--dp--gping4--bunny.cdn
central-america--dp--gping4--cachefly.cdn
central-america--dp--gping4--cdnetworks.cdn
central-america--dp--gping4--cloudflare.cdn
central-america--dp--gping4--digitalocean.cdn
central-america--dp--gping4--fastly.cdn
central-america--dp--gping4--gcp.cdn
central-america--dp--gping4--scaleway.cdn
central-america--dp--gping4--tencent.cdn
eu--dp--adns--akamai.dns
eu--dp--adns--alibaba.dns
eu--dp--adns--aws.route53
eu--dp--adns--azure.dns
eu--dp--adns--bunny.dns
eu--dp--adns--cloudflare.dns
eu--dp--adns--digitalocean.dns
eu--dp--adns--dnsmadeeasy.dns
eu--dp--adns--easydns.dns
eu--dp--adns--gcp.dns
eu--dp--adns--ns1.dns
eu--dp--adns--rage4.dns
eu--dp--adns--ultradns.dns
eu--dp--aping4--akamai.cdn
eu--dp--aping4--alibaba.cdn
eu--dp--aping4--aws.cloudfront
eu--dp--aping4--bunny.cdn
eu--dp--aping4--cachefly.cdn
eu--dp--aping4--cdnetworks.cdn
eu--dp--aping4--cloudflare.cdn
eu--dp--aping4--digitalocean.cdn
eu--dp--aping4--fastly.cdn
eu--dp--aping4--gcp.cdn
eu--dp--aping4--scaleway.cdn
eu--dp--aping4--tencent.cdn
eu--dp--gping4--akamai.cdn
eu--dp--gping4--alibaba.cdn
eu--dp--gping4--aws.cloudfront
eu--dp--gping4--bunny.cdn
eu--dp--gping4--cachefly.cdn
eu--dp--gping4--cdnetworks.cdn
eu--dp--gping4--cloudflare.cdn
eu--dp--gping4--digitalocean.cdn
eu--dp--gping4--fastly.cdn
eu--dp--gping4--gcp.cdn
eu--dp--gping4--scaleway.cdn
eu--dp--gping4--tencent.cdn
mea--dp--adns--akamai.dns
mea--dp--adns--alibaba.dns
mea--dp--adns--aws.route53
mea--dp--adns--azure.dns
mea--dp--adns--bunny.dns
mea--dp--adns--cloudflare.dns
mea--dp--adns--digitalocean.dns
mea--dp--adns--dnsmadeeasy.dns
mea--dp--adns--easydns.dns
mea--dp--adns--gcp.dns
mea--dp--adns--ns1.dns
mea--dp--adns--rage4.dns
mea--dp--adns--ultradns.dns
mea--dp--aping4--akamai.cdn
mea--dp--aping4--alibaba.cdn
mea--dp--aping4--aws.cloudfront
mea--dp--aping4--bunny.cdn
mea--dp--aping4--cachefly.cdn
mea--dp--aping4--cdnetworks.cdn
mea--dp--aping4--cloudflare.cdn
mea--dp--aping4--digitalocean.cdn
mea--dp--aping4--fastly.cdn
mea--dp--aping4--gcp.cdn
mea--dp--aping4--scaleway.cdn
mea--dp--aping4--tencent.cdn
mea--dp--gping4--akamai.cdn
mea--dp--gping4--alibaba.cdn
mea--dp--gping4--aws.cloudfront
mea--dp--gping4--bunny.cdn
mea--dp--gping4--cachefly.cdn
mea--dp--gping4--cdnetworks.cdn
mea--dp--gping4--cloudflare.cdn
mea--dp--gping4--digitalocean.cdn
mea--dp--gping4--fastly.cdn
mea--dp--gping4--gcp.cdn
mea--dp--gping4--scaleway.cdn
mea--dp--gping4--tencent.cdn
north-america--dp--adns--akamai.dns
north-america--dp--adns--alibaba.dns
north-america--dp--adns--aws.route53
north-america--dp--adns--azure.dns
north-america--dp--adns--bunny.dns
north-america--dp--adns--cloudflare.dns
north-america--dp--adns--digitalocean.dns
north-america--dp--adns--dnsmadeeasy.dns
north-america--dp--adns--easydns.dns
north-america--dp--adns--gcp.dns
north-america--dp--adns--ns1.dns
north-america--dp--adns--rage4.dns
north-america--dp--adns--ultradns.dns
north-america--dp--aping4--akamai.cdn
north-america--dp--aping4--alibaba.cdn
north-america--dp--aping4--aws.cloudfront
north-america--dp--aping4--bunny.cdn
north-america--dp--aping4--cachefly.cdn
north-america--dp--aping4--cdnetworks.cdn
north-america--dp--aping4--cloudflare.cdn
north-america--dp--aping4--digitalocean.cdn
north-america--dp--aping4--fastly.cdn
north-america--dp--aping4--gcp.cdn
north-america--dp--aping4--scaleway.cdn
north-america--dp--aping4--tencent.cdn
north-america--dp--gping4--akamai.cdn
north-america--dp--gping4--alibaba.cdn
north-america--dp--gping4--aws.cloudfront
north-america--dp--gping4--bunny.cdn
north-america--dp--gping4--cachefly.cdn
north-america--dp--gping4--cdnetworks.cdn
north-america--dp--gping4--cloudflare.cdn
north-america--dp--gping4--digitalocean.cdn
north-america--dp--gping4--fastly.cdn
north-america--dp--gping4--gcp.cdn
north-america--dp--gping4--scaleway.cdn
north-america--dp--gping4--tencent.cdn
south-america--dp--adns--akamai.dns
south-america--dp--adns--alibaba.dns
south-america--dp--adns--aws.route53
south-america--dp--adns--azure.dns
south-america--dp--adns--bunny.dns
south-america--dp--adns--cloudflare.dns
south-america--dp--adns--digitalocean.dns
south-america--dp--adns--dnsmadeeasy.dns
south-america--dp--adns--easydns.dns
south-america--dp--adns--gcp.dns
south-america--dp--adns--ns1.dns
south-america--dp--adns--rage4.dns
south-america--dp--adns--ultradns.dns
south-america--dp--aping4--akamai.cdn
south-america--dp--aping4--alibaba.cdn
south-america--dp--aping4--aws.cloudfront
south-america--dp--aping4--bunny.cdn
south-america--dp--aping4--cachefly.cdn
south-america--dp--aping4--cdnetworks.cdn
south-america--dp--aping4--cloudflare.cdn
south-america--dp--aping4--digitalocean.cdn
south-america--dp--aping4--fastly.cdn
south-america--dp--aping4--gcp.cdn
south-america--dp--aping4--scaleway.cdn
south-america--dp--aping4--tencent.cdn
south-america--dp--gping4--akamai.cdn
south-america--dp--gping4--alibaba.cdn
south-america--dp--gping4--aws.cloudfront
south-america--dp--gping4--bunny.cdn
south-america--dp--gping4--cachefly.cdn
south-america--dp--gping4--cdnetworks.cdn
south-america--dp--gping4--cloudflare.cdn
south-america--dp--gping4--digitalocean.cdn
south-america--dp--gping4--fastly.cdn
south-america--dp--gping4--gcp.cdn
south-america--dp--gping4--scaleway.cdn
south-america--dp--gping4--tencent.cdn