# Infrastructure scope: network, device and kernel data

**Draft, awaiting the owner's ratification of version 1.0.** The decision behind it (OD-DP-02,
taken 2026-10-28) is that the line against an infrastructure AI-SRE bars diagnosing and acting on
infrastructure, not observing it, and that this page is the line's public text. The ratification is
recorded against a version of this page, and none is recorded yet; until it is, this page says what
Bucker does today and does not promise that it will not change.

This page says what Bucker does about network infrastructure data, in one statement and one table,
so that nobody has to infer the boundary from silence. The table is generated from
`coverage-map.json`, kept beside this page in the repository, version 1.0, as of 2026-10-28, so an
agent asked "can Bucker see packet loss?" can answer from this page and cite the map's version
instead of guessing.

## The statement

> Bucker does not collect, store or diagnose network infrastructure telemetry. It does not poll SNMP devices, receive NetFlow, sFlow or IPFIX, run an eBPF agent, map cloud network topology or manage device configuration. It does monitor the network as your application experiences it: reachability, DNS, TLS and latency of the endpoints your users and your code depend on, measured from outside by monitors and from inside by the OpenTelemetry spans and metrics your services already send, and it links those signals to issues, traces, releases and sessions. For device, flow and kernel-level network data, keep a network tool and send its alerts to Bucker.

The same applies to GPU, process and host-agent features: Bucker has no host agent, so they are listed
below as not collected.

## How to read the map

Every row has a **route**, and the route says who does the collecting.

- **Collected.** Bucker collects it itself, through a monitor or an ingest door it runs. The
  status says how much of the signal that covers.
- **Accepted.** Bucker accepts it only as ordinary OTLP from a Collector or an SDK **you** run
  ([OTLP ingest](otlp.md)). It is stored and metered as any other point or record (0.05 units each,
  inside the 1,000-series-per-metric cap), and nothing is built on it: no topology, no product
  surface, no network AI. The maturity named is the upstream component's own label (alpha,
  development, v0), not a promise of Bucker's.
- **Not collected.** Bucker does not collect it and does not accept it as a signal of its own. The
  row says where to get it instead.

Statuses: *shipped* (built and reachable), *partial* (built for part of the signal, and the row says
which), *accept only* (accepted as OTLP; no recipe, dashboard or detector), *gated* (accepted only
after the conditions in the row are met; no recipe is published before then) and *not offered*.

The first twelve rows are every signal in the network-monitoring comparison this page was written
against (which signals need an on-host agent, and which are reachable without one). The rest are the
things the statement itself names, and the GPU, process and host-agent features.

## The coverage map

<!-- coverage-map:begin (generated from coverage-map.json) -->

| Signal | Route | Status | What Bucker does | Instead |
| --- | --- | --- | --- | --- |
| Per-connection TCP health (RTT, retransmits, resets, refusals, timeouts) | Accepted | Gated | OpenTelemetry eBPF Instrumentation (OBI) `obi.stat.tcp.*` metrics, v0, run by the customer and sent as OTLP http/protobuf. Listed as accepted only after OBI v1.0.0, once Explore computes percentiles from histogram buckets and a series budget has been measured; until then no recipe is published and the OBI-specific names are outside any stability promise. | A network or APM tool with an eBPF or driver agent; send its alerts to Bucker. |
| Flow volume between endpoints | Accepted | Accept only | Cloud flow logs (AWS VPC, GCP VPC) turned into OTLP logs by a Collector the customer runs: `awslogsencodingextension` (alpha) and `netflowreceiver` (alpha). Stored as ordinary log records at 0.05 units each; no aggregation, no topology, no flow view. | Your cloud provider's flow-log tooling or a network tool; send its alerts to Bucker. |
| Application golden signals without code | Collected | Shipped | OTLP/HTTP traces and metrics from an OpenTelemetry SDK or auto-instrumentation, in Explore, alerts and dashboards. OBI RED metrics follow the same gate as the TCP row above. |  |
| Third-party API health by host | Collected | Partial | From the client spans and `http.client.request.duration` metrics your services send. The Node SDK emits no automatic outbound HTTP spans, only through the OpenTelemetry bridge, and a call to a third party makes no service-map edge. There is no per-hostname view yet. |  |
| DNS as clients see it (requests, latency, rcode per server) | Not collected | Not offered | Client-side DNS needs an eBPF parser on the host; Bucker runs none. An active probe from outside is the row for the names your users and code depend on, below. | Route 53 Resolver query logs or Cloudflare DNS Analytics for the authoritative side, or OBI on a host you run (client queries only). |
| TLS expiry and handshake health | Collected | Partial | HTTPS uptime monitors read certificate expiry from the first handshake and raise an `uptime_cert_expiry` issue (14 days by default). There is no chain, hostname, protocol or OCSP check, and nothing for TLS on a non-HTTP port. |  |
| Load-balancer and proxy health | Accepted | Accept only | CloudWatch or Prometheus receivers in a Collector the customer runs (alpha or development; the Fly proxy metrics route is untested here), sent to /v1/metrics as ordinary points. Bucker has no pull or scrape path of its own. | The provider's own console for load-balancer and edge metrics. |
| Hop-by-hop path, loss, ASN | Not collected | Not offered | Needs raw sockets or a managed prober. Bucker's probes are HTTP(S) today, and the bounded form on record allows single-hop DNS, TCP, TLS and HTTP probes only: never traceroute, ICMP or UDP. | A traceroute or path-testing tool (MTR, a managed path tester); send its alerts to Bucker. |
| Device telemetry (interfaces, CPU, BGP peers, traps, config) | Not collected | Not offered | Out of scope. A Collector `snmpreceiver` (alpha; manual OID mapping, no profiles, no traps) can send interface counters as ordinary OTLP metrics, which Bucker stores as points and does nothing more with. | Keep your network management tool for devices, traps, BGP and configuration history; send its alerts to Bucker. |
| Host NIC counters | Accepted | Accept only | The `hostmetricsreceiver` network scraper (development) in a Collector the customer runs, sent to /v1/metrics as ordinary points under the 1,000-series-per-metric cap and the 0.05-unit weight. | Your host or platform monitoring (Fly `fly_instance_net_*` through its own Prometheus). |
| Reachability (ping, TCP connect) | Collected | Partial | HTTP and HTTPS only. Ping and TCP connect have no monitor kind; a Collector with `tcpcheckreceiver` (alpha) or `icmpcheckreceiver` (development) can send the results as ordinary OTLP metrics. | An external synthetic service for ICMP and raw TCP checks. |
| Firewall and security-group decisions | Not collected | Not offered | Needs the cloud provider's APIs and flow-log REJECT records. Not meaningful on a platform-as-a-service, which is where Bucker's own services run. | Your cloud provider's security tooling and flow-log analysis. |
| Reachability and latency of the HTTP(S) endpoints your users and code depend on | Collected | Shipped | HTTP(S) uptime monitors with status, header, body and JSON assertions, redirects and `traceparent`, from the locations that run (one is deployed today; more only on demand). |  |
| DNS of the names your users and code depend on, from outside | Collected | Partial | An HTTP monitor whose name does not resolve fails with one collapsed 'unresolvable target' message. There is no DNS check kind: no record, rcode, TTL or nameserver check. | A DNS monitoring service for record-level checks, or `dnscheckreceiver` (development) in a Collector you run. |
| Polling SNMP devices | Not collected | Not offered | Bucker has no poller and no SNMP credential store. | An SNMP-capable network monitoring tool; send its alerts to Bucker. |
| Receiving NetFlow, sFlow or IPFIX | Not collected | Not offered | Bucker listens on no flow port. Flow records a customer converts to OTLP logs are the flow-volume row. | A flow collector or network tool; send its alerts to Bucker. |
| Running an eBPF agent | Not collected | Not offered | Bucker ships no host agent and no eBPF program, by decision (a sandbox, eBPF profiler or traffic recorder of its own is not built; open-source tools are reached through a seam only). | OBI, Microsoft Retina or Coroot on a host you run, with their own backend, or OBI over OTLP once it meets the gate in the TCP row. |
| Mapping cloud network topology | Not collected | Not offered | Bucker's service map is an edge table built from parent and child spans, not a network map. It reads no cloud network API. | Your cloud provider's network console or a network topology tool. |
| Managing device configuration | Not collected | Not offered | Bucker never writes to a device and holds no device credential, so there is no configuration backup, diff or rollback. | A network configuration management tool; send its alerts to Bucker. |
| Kernel-level telemetry (syscalls, packet capture, kernel probes) | Not collected | Not offered | Nothing in Bucker runs in a customer's kernel or captures packets. | eBPF and packet-capture tools you run yourself; send their alerts to Bucker. |
| GPU monitoring (utilisation, memory, workload attribution) | Not collected | Not offered | Needs an on-host agent. A DCGM exporter scraped by a Collector you run lands as ordinary OTLP metrics, with no GPU page or attribution. | NVIDIA DCGM exporter with your own dashboards, or your GPU provider's console. |
| Process-level monitoring (live processes, per-process CPU and memory) | Not collected | Not offered | Needs a host agent. The `hostmetricsreceiver` process scraper (development) in a Collector you run lands as ordinary OTLP metrics. | Your host agent or the Collector's process scraper, with its own view. |
| A Bucker host agent (host inventory, host map, per-host metrics, per-host billing) | Not collected | Not offered | There is no Bucker agent and no host entity; nothing is billed per host. Customers who want host metrics run an OpenTelemetry Collector and send ordinary OTLP. | An OpenTelemetry Collector you run, or your platform's own host monitoring. |

<!-- coverage-map:end -->

## What this page is not

- **Not an AI-SRE.** Bucker does not diagnose network incidents, advise on sizing or capacity, or
  act on a network. Observing is allowed; diagnosing and acting are not (OD-DP-02).
- **Not a promise of a recipe.** OpenTelemetry eBPF Instrumentation is listed as accepted *after*
  v1.0.0, once Explore computes percentiles from histogram buckets and a series budget has been
  measured. Until then it is gated, and no recipe is published.
- **Not a network product.** Anything in the *accepted* rows lands as ordinary points or records.
  There is no network view, device inventory, topology map or per-host meter, and none is planned
  under this statement.
- **Not a claim about other pillars.** Uptime monitors, status pages, issues and traces are
  described on their own pages ([uptime monitoring](uptime.md), [status pages](status-pages.md)).

## Where the same answer is served

- This page, with every row of the map and its version, through the documentation tools
  (`search_docs`, `get_doc`), as Markdown at `/docs/infrastructure-scope.md` and in the
  [docs manifest](https://bucker.io/docs/manifest.json).
- The [trust page](https://bucker.io/trust), which links it beside the sub-processor list.
- Planned, not built: the infrastructure setup read will serve the map itself, `coverage-map.json`
  (the same rows, with the statement), and cite its version beside every coverage label it prints.
  Until then the JSON is kept in the repository and not served at an address of its own.
